The central feature of Pandas is the tabular data-frame data structure. It adds functionality on top of NumPy arrays such as labelled indexing, time-series analysis, and data manipulation routines (querying, filtering, sub-setting).¹

SciPy relies on NumPy to build functionality such as modules for optimisation, interpolation, integration, linear algebra, signal processing, and more.²

scikit-learn is a popular machine learning library. NumPy’s efficient array operations and memory management makes it well-suited for large-scale computations required in machine learning tasks such as regression and classification.³

Matplotlib is a plotting library in Python that works with NumPy arrays to create static, interactive, and animated visualisations.⁴ Seaborn, another data visualisation library, also makes use of NumPy arrays for data input to plots.⁵

NumPy serves as a bridge between deep learning frameworks like TensorFlow⁶ and PyTorch⁷ and the rest of the Python scientific computing ecosystem. These frameworks allow conversion between NumPy arrays and their own data objects.

PyArrow is the Python interface to the Apache Arrow columnar data format; a specialised data format for fast in-memory analytics. It integrates seamlessly with NumPy arrays.⁸

Statsmodels is a library for statistical modelling and hypothesis testing in Python. It relies on NumPy arrays for data representation and manipulation, allowing users to perform various statistical analyses such as regression, time series analysis, and hypothesis testing, using familiar NumPy syntax.⁹

OpenCV is a computer vision library that utilises NumPy arrays for representing and processing image and video data, implementing processing tasks such as filtering, transformation, and feature extraction.¹⁰

NumPy introduces fundamental concepts in numerical computing such as array and matrix manipulation, vectorised operations, and broadcasting. Understanding these concepts can help you make better choices when solving data manipulation problems.

Many concepts and techniques learned in NumPy are transferable to other libraries and languages. For example, understanding array operations in NumPy can make it easier to work with similar data structures in other languages like MATLAB or R.

NumPy serves as a foundation for more advanced topics in numerical computing such as linear algebra, Fourier analysis, optimisation, and signal processing. Knowledge of these foundational concepts can be valuable in various fields.

As we’ve seen, many other libraries and frameworks in the Python ecosystem build upon or interact with NumPy. Understanding NumPy can facilitate your use of these libraries.

Proficiency in NumPy is often a requirement or desirable skill for roles in data science, machine learning, scientific computing, and related fields. Familiarity with it can enhance your employ-ability.

NumPy has a large and active community, so there are ample resources available for learning and troubleshooting. You gain access to a wealth of tutorials, documentation, forums, and open-source projects to support learning and implementation.

Understanding NumPy provides a solid foundation for expanding into more advanced topics in data analysis and scientific computing, empowering data developers to tackle the complexity of data-driven applications.

Python itself does not have built-in support for arrays of more than basic utility (i.e. lists), which is where libraries like NumPy come in. The array object provides some extra capability around strict typing (this is discussed in more detail in Appendix B - Python Lists & array Vs NumPy Arrays) but they also fall seriously short of what NumPy can do.

Arguably, NumPy has become the de facto standard for array, matrix, and numerical computation in the scientific Python community.

Python is a scripting language, which means all you need is a script — a text file containing Python code — and a Python interpreter to execute the code. It will then output the results of your program, or any errors that are preventing the code from being executed correctly. There can be more than one script file for a program, allowing you to separate code into modules⁴. But for simplicity, begin with a single script file, name it anything you like, for example numpy_starter.py, and write the following line of code:

Save your file, and open a terminal console and change into the directory of the script. To execute, simply type in the following and press [Enter]:

You should see 'Hello world!' echoed to the console.

There are many online resources for learning how to run Python scripts, including: How to Run Your Python Scripts and Code⁵.

IPython is a special shell environment for interacting with Python in a REPL^* fashion. It’s simple to install using pip:

Once installed, run the command ipython from your console and you’ll enter the IPython interactive environment. Here you can write Python code as you would in a script and execute that code with the [Enter] key. Here is an example interaction:

As you can see, once you run the code (it can be over more than one line) it presents the results, then prompts you for more input — and, handily, it remembers variables or functions declared during a session. To learn more about IPython, go to the IPython website⁶.

^* REPL stands for Run-Eval-Print-Loop. See the REPL Wikipedia entry⁷.

Jupyter originated from IPython, expanding its capabilities within interactive scientific notebooks. The application is easily installed using pip:

Jupyter runs as a web application on your local machine, and can be started with the following command:

To run system commands from within an IPython shell, you need to begin the command with an !:

Once the web application launches, you can either open an existing notebook (they have the .ipynb file suffix), or create a new one — choosing the “Python kernel” option for your new notebook. You run code from within a notebook inside code “cells”, like so:

To learn more about installing and using Jupyter, visit the official Quick Start Guide⁸.

Importing the NumPy library as np is considered a standard practice.

The example code in this book was prepared and tested using NumPy version:

It’s easy to get in-line help information (often with example usage) on numpy objects such as classes, arrays, and functions:

numpy.add is one of many array computation functions that NumPy offers. This, and many other array operations will be highlighted throughout the book.

You can use Python’s built-in help() function to search for documentation related to specific modules, classes, or functions. For example:

If you’re looking for all the attributes and methods available in a module or object, dir() is helpful:

You can programmatically control the way arrays and numbers are formatted for display. Here’s an example output with default display (no explicit setting):

Here’s the same array output with a (temporary) custom display setting:

dtype creation with a NumPy object, and its string (alternative) variation:

dtype creation using a sized alias:

dtype creation using Python built-in aliases:

The following chapter on Array Creation will demonstrate how explicitly referencing or creating dtype objects can be done during the array creation process.

dtype creation, each field is assigned a name and type (like a key/value pair):

dtype creation, specify names and formats separately as lists:

dtype creation, specify formats as strings alone (where names not required):

Here’s the output for numpy.e:

And for numpy.pi:

Create a new 64 byte dtype of float type, using a sized alias, and assign it to the variable t. Print out the variable.

Repeat the above dtype creation, but instead using an equivalent native Python type.

Write a Python expression that calculates the area of a circle with radius of 30mm. (Result will be in units of mm²)

Convert the result of the area of the circle to units of cm². Print the result.

An array’s data type is determined by the provided list’s values (integers default to numpy.int64):

Same as the previous example, but with a preassigned list:

Array values are implicitly promoted to the largest type (in this example cast to numpy.float32):

Explicitly force the type (values are promoted to numpy.float64):

Explicitly force the type (demote all values to numpy.int32):

Assign a dtype and pass it to array():

Fill an array (of this shape) with meaningless values, requiring correct initialisation later:

You might expect an “empty” array to be filled with zeros or None (Python’s version of Null) values. np.empty should therefore be used with caution, as whilst the values it generates are meaningless, they may introduce invalid computation results in your code until populated with meaningful values.

Just some zeros please:

Nothing but ones:

Fill / pad a new larger array with a smaller list:

Get a spread of values from within the range {0 < 12} in increments of 2:

Get four values equally spaced within the range {0 <= 6} (inclusive):

Get four values spaced evenly on a base 10 log scale between {0 <= 2}:

Use a seed to ensure the same values are reproduced, if required:

42 was chosen arbitrarily, but it can be any other number of your choosing.

Create a 2x1 array containing random float values in the range {0. <= 1}:

3x4 array of random int values in the range {–2 <= 10}:

Modify a sequence in-place by shuffling its contents (only shuffles the array along the first axis):

Randomly permute a sequence:

3x4 array of random, normally distributed values in the range {0. <= 10.}:

3x4 array of random values in the standard normal distribution range:

* “See also” short descriptions and links, courtesy of numpy.org.

Create array from an array-like object (creates a copy if a is an ndarray):

Array of ones with the same dimensions as the array-like input:

Array of zeros with the same dimensions as the array-like input:

Array of preferred values with the same dimensions as the array-like input:

Empty (meaningless values) array with the same dimensions as array-like input:

Cast to different type (creates a copy of the array):

Explicitly copy an array:

copy also works with sub-setting:

Sub-setting is a feature of NumPy that allows you to extract precise subsets of an array. Chapter 7. Array Selection & Modification covers this topic in detail, along with other powerful ways to access array data.

Create an array from an array-like string:

Identity matrix of dimension n x n:

Matrix of suitable dimension given diagonal:

Identity matrix of dimension NxN shifted by a diagonal offset (k):

Generate a Vandermonde matrix:

Lower triangle of an array, with zeros above:

Structured arrays are useful for when you need to work with heterogeneous data:

Structured arrays are a way of implementing mixed types in NumPy. They may affect the performance and utility of your array, so use them with caution.

Create a regular array with named compound type, and convert it to a record array:

Confirm this is a recarray object:

Create an uninitialised record array of shape (2,2) and initialise the array:

Notice that the data type is an instance of record:

Create an array from a text or binary file:

Load an array from a text (commonly CSV) file:

Load an array from a Python pickle object:

Load text into an array with tidying capabilities:

Refer to Appendix C. NumPy Function & Property Reference (or the online documentation¹) for a full list of array creation functions available in the numpy module.

Create a 2-D Python list of the test scores, with the student scores as “rows” in test order. Assign this list to the variable student_scores_list. Print out this list.

Using the list from Exercise 4-1, create a NumPy array assigned to student_scores_arr, and explicitly assign it an appropriate floating point dtype. Print out the array.

Create a copy of student_scores_arr whilst assigning it to a new variable. Change the type of the copied array to a suitable integer. What do the scores look like now? What effect did the conversion have on the values?

Create a new array filled with ones, of the same dimensions as student_scores_arr. Print the array. What is the dtype of this array?

Create an identity matrix of 4x4 size, and print the result.

Design a suitable named compound type for student_scores_arr (using sensible names without spaces), where the student id is an integer, and the scores are a floating point. Recreate the scores array to use this compound type. Print out the dtype for the array. (Hint: use tuples as rows.)

Convert the structured array created in Exercise 4-6 to a recarray array. Print out the 2^nd field (column) of the record array by name.

Get the shape of the array — a tuple indicating the length of each dimension:

The number of dimensions:

The total number of elements in the array:

Length of an element, in bytes:

Information about the memory layout of the array:

Test if all elements in an array evaluate to True:

Test if any (at least a single) element evaluates to True:

The array’s data type (dtype):

Name of the array’s data type:

Character code of the data type:

Get the unique number for this data type:

Get a printable string of an array’s contents:

Get a string of an array plus info about its type:

What is the shape of the above NumPy array? Use the array’s shape property to confirm your conclusion.

What is the size of each element in this array, in bytes?

Use the appropriate inspection property to find the total bytes consumed by the array. How does this compare to the multiple of the previous exercise’s result by the total count of elements?

What is the string name of the data type of this array?

If a third row containing the elements [7 8 9] was added to the array, what would be the number of dimensions?

Persist a single array to a file in binary format:

Read the file back into an array variable:

Persist multiple arrays to an archive file:

Load the archive back into the array variables:

An alternative to savez is savez_compressed, which is used exactly the same way except with compression to reduce the size of the file. The data is uncompressed on load in the same way as before using np.load(), and nothing special needs to be done. Be aware that extra compress or uncompress steps can affect program performance with larger files.

Here we see how simple it is to save an array to CSV:

The contents of the CSV file will look like this:

A CSV file very often comes with a header row that represent a name for each “column”, for example:

The skiprows argument can be used to ignore the header when reading the file into an array:

Create a file called student_scores.csv and save it to your computer, adding to it the following contents:

Load the file into a NumPy array, excluding the header, and print the array.

Load the array instead using the compound type:

Print the new array.

Hint: Try using genfromtext with the names=True attribute.

Convert the array you created in Exercise 6-2 to a recarray, and print out a list of the student numbers using the array.field notation.

Indexing on 1-D arrays (vectors) is similar to indexing with Python lists. The following examples use the array a = np.array([1, 2, 3, 4]), depicted as:

1 2 3 4

Remember that Python indexing is zero-based, so the index at value 1 is [0], value 2 is [1], and so on. Let’s look at some common techniques for indexing simple NumPy arrays:

* The first method uses simple indexing, but the rest are slicing operations — which create a volatile “view” of the underlying array.

Array modification is also possible using indexing or slicing, but the data being targeted must match the dimensions of the slice, or be a scalar. (This is an early peak into broadcasting, see the section Chapter 8. Array Computation for more on this topic).

The following examples show the array a = np.array([1, 2, 3, 4])being progressively modified:

Recall that common indexing or slicing creates a “view” of the underlying array, meaning changes to the sub-set will affect the original array it was sliced from. As a demonstration:

Select all rows, 2^nd column:

Select 2^nd row, all columns:

Select all rows, every 2^nd column:

Single element (2^nd row, 3^rd column):

Modify the last column:

The following examples use the arrays:  

1 2 3 4

and:

1 2

Boolean indexing with NumPy allows you to select elements from an array based on a condition, targeting the array’s values at indexes that meet the condition (is True). Consider the following examples, where:

First, let’s see what b evaluates to:

b is assigned the result of an element-wise conditional evaluation; in this case returning True where each value, v, in a, meets the condition v < 2, otherwise returning False. So to proceed, we have the variables a and b to work with:

a = 1 2 3 4 — a NumPy array.

b = True False False False — a simple Python list.

Get a list of (only) the scores of the 1^st student.

Print out student IDs of the 1^st two students.

Modify the score of the 2^nd student in the second test to 87.

Print the scores of all students in the 3^rd test.

Modify the scores of all students in the 4^th test to 75.

Print the scores of the 2^nd student in the last two tests.

Modify the scores of all students in the 1^st test to 70.

Print the ID and scores of the last student.

Repeat the selection from Example 7-8 but assign it to the variable sub_arr. Change the first score of sub_arr to 77. Is this sub-selection a view? Confirm by printing both sub_arr and scores_array to see if the original array has also been modified.

Retrieve an array of the scores only (no student id) and apply a conditional expression to return True|False for any scores over 80.

Element-wise absolute value for int or float:

Ceiling or floor of each element:

Round to nearest int or decimal:

Calculate the square root or square:

Exponentiation — (e^x, 2^x, ¹/x):

Natural log, base 10 log, base 2, log(1+x):

Get the sign of each number (1 or -1):

Split an array into [fraction, integral] parts:

Test for NaN, +/-infinity, finiteness:

Trigonometric functions and their hyperbolic and inverse relations:

Evaluate this if condition met, otherwise that:

Get the truth values of a negation:

Real or imaginary component of imaginary numbers:

Common arithmetic functions and their operator shortcuts:

Element-wise equality tests:

Scalar operations with 1-D arrays:

Where: a = np.array([1, 2, 3])

Scalar operations with 2-D arrays:

Where: a = np.array([[1,2,3], [4,5,6]])

Operations between 1-D and 2-D arrays:

Where: a = np.array([[1,2,3], [4,5,6]])

Where: b = np.array([[2.], [3.]])

Perform a ‘dot’ product on two matrices:

With matrix multiplication (where at least one array is 2-D), the number of columns of the first matrix must match the number of rows of the second matrix (where A is an m x n matrix, and B is n x p). The resulting matrix is of dimension m x p. Here is the above example in matrix notation:

The dot product will behave differently if one side is a scalar. Let’s compare a scalar vs a 1x1 array dot product with a 2-D array:

The dot operation falls back to a “scalar * array” operation. Whereas an explicit 1x1 array fails, as it will attempt to perform the “matrix dot matrix” product operation with incompatible dimensions:

Where: a = np.array([[1,2,2], [4,4,6]]), get the unique values:

Find the union of two arrays:

Test whether each element of a 1-D array is also present in a second array:

Logic tests. Where a = np.array([[1, 2], [3, 4]]):

Stats operations. Where: a = np.array([[1, 2], [3, 4]]):

Perform element-wise addition (+) and multiplication (*) of the two arrays and print the results.

Does the matrix dot operation between the arrays result in a valid array? Print the result. Can you explain how the result was generated?

Perform element-wise comparison (greater than, less than, equal to) between the elements of these arrays. Print the result of each comparison.

Perform scalar division on the array a with the value 5. Print the resulting array. What is the dtype of the result?

Create a larger NumPy array b with dimensions (3, 3) containing random values. Then, add array a to b. Print the resulting array.

Given the following NumPy array:

What percentage of student scores are over 80?

Hint: think about summation of a Boolean array from the result of an element-wise math expression (True evaluates to 1, False to 0).

Compute the mean and standard deviation of the NumPy array arr:

Compute and print out the median and quartiles (25th and 75th percentiles) of the following NumPy array arr:

Compute and print out the correlation coefficient between the two NumPy arrays x and y:

Would you say these arrays are strongly correlated, weakly correlated, or not correlated? If correlated, in what direction?

Transpose a 2-D array:

Transposing returns a view of the array. a.swapaxes(0,1) achieves the same result.

Reshape a 2x3 array to 3x2:

New and old shapes must be compatible. Eg a.reshape(2,2) would result in an error. But np.reshape(a, (1,6)) yields: [1, 2, 3, 4, 5, 6].

Flatten an array into a vector:

Flattening with order:

See the API docs for various Flip and reverse ordering options.

Rotate by flip & reverse:

Rotate by flipping on axis:

Flip and rotate operations behave as you’d expect, with variations depending on optional arguments. Note flip(a,0) ~= flipud(a) and flip(a,1) ~= fliplr(a).

Rotate an array by 90 degrees in the plane specified by axes:

Join arrays in sequence along an axis:

Arrays must have the same shape, except in the dimension corresponding to the given (or default) axis.

Combine & flatten into a vector:

The concatenate function creates a copy of the data.

Split into multiple arrays:

The following example will make use of the 1D array, a = np.array([1, 2, 3, 4, 5, 6]):

1 2 3 4 5 6

The following examples will make use of the arrays:

Depicted as:

1 2 3

and:

4 5 6

Sort by ‘row’:

Sort by ‘row’, but output the index:

Flatten, then sort:

Sort by ‘column’:

Convert the array a = np.array([[1, 2], [3, 4]]):

1 2

3 4

So that it looks like this:

1 3

2 4

Is it possible to reshape the 2x2 array a = np.array([[1, 2], [3, 4]]) into a 4x1 array? If so what is the procedure? Assign this new array to variable b.

Flatten the arrays a and b from exercise 9-2, and combine them into a single 2x4 array assigned to c, resulting in:

Use a rotate operation upon c to convert it into the 2x4 array:

Convert the 1-D array a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9]) into a 3x3 array sorted in reverse order, so that the result is:

String arrays can be tested for any; if at least one element evaluates to True:

String arrays can also be tested for all; if every element evaluates to True:

String arrays can be easily converted to lower or upper-case, or even capitalised:

String array values may be self-concatenated to produce repeating values:

Replacing text inside strings is straighforward:

Compare the equality of string arrays to return an array of True | False values:

Find the occurances of a string in the array:

Check whether any values are numeric (the entire value represents a number):

Test whether any value starts with, or ends with a sub-string:

Swap the case of the following array so that uppercase letters are converted to lowercase, and lower to upper:

Pad the following array of numeric strings with zeros, up to a width of 4:

Test whether the values in the following array consist only of alphabetic characters:

Find the length of each value in the previous array.

One of the most popular programs for creating virtual environments is virtualenv, itself a package that you install via PyPI:

Once installed you’re ready to create virtual environments. It’s a good idea to have a top-level folder under which all your virtual environments reside. From now on we’ll refer to a virtual environment simply as a “venv”.

To create a venv, change into the directory of the parent location for your venvs. Existing venvs will reside here as sub-directories. To create a venv run the following command:

The name of the venv can be anything you like, but of course uniquely named under this location. To enter a venv you need to ‘activate’ it, for example:

You can do this from anywhere by passing the fully qualified path to the venv folder:

In windows this might look like this (a . (dot) operator is equivalent to source):

When you enter the venv, you’ll notice a special prompt that informs you that you’re inside a venv. For example:

Once you’re in the venv, you can execute python scripts or install packages as you would normally.

(Output not shown)

Packages will be installed for this venv without knowledge of other venvs. You can then run your programs as you would in a global environment:

To exit out of a venv, shut down any running programs and type:

and you’ll be returned to a regular console prompt.

There’s a lot more to virtual environments in Python (including the ability to enter/execute/exit them via shell scripts), so consult the online documentation or follow a good tutorial.

Create a new 64 byte dtype of float type, using a sized alias, and assign it to the variable t. Print out the variable.

Repeat the above dtype creation, but instead using an equivalent native Python type.

Write a Python expression that calculates the area of a circle with radius of 30mm.

Convert the result of the area of the circle to units of cm². Print the result.

Create a 2-D Python list of the test scores, with the student scores as “rows” in test order. Assign this list to the variable student_scores_list. Print out this list.

Using the list from Exercise 4-1, create a NumPy array assigned to student_scores_arr, and explicitly assign it an appropriate floating point dtype. Print out the array.

NumPy arrays must be of the same type, in this case whole numbers (integers) were promoted to floating point values.

Create a copy of student_scores_arr whilst assigning it to a new variable. Change the type of the copied array to a suitable integer. What do the scores look like now? What effect did the conversion have on the values?

The effect of the conversion was to round down (take the floor of) the values.

Create a new array filled with ones, of the same dimensions as student_scores_arr. Print the array. What is the dtype of this array?

Create an identity matrix of 4x4 size, and print the result.

Design a suitable named compound type for student_scores_arr (using sensible names without spaces), where the student id is an integer, and the scores are a floating point. Recreate the scores array to use this compound type. Print out the dtype for the array. (Hint: use tuples as rows.)

Convert the structured array created in Exercise 4-6 to a recarray array. Print out the 2^nd column of the record array by name.

What is the shape of the NumPy array? Use the array’s shape property to confirm your conclusion.

This is a 2x3 array. This can be confirmed using:

What is the size of each element in this array, in bytes?

Use the appropriate inspection property to find the total bytes consumed by the array. How does this compare to the multiple of the previous exercise’s result by the total count of elements?

size gives you the number of elements, therefore:

What is the string name of the data type of this array?

If a third row containing the elements [7 8 9] was added to the array, what would be the number of dimensions?

Adding a new row simply increases the size of the 0^th dimension, so the number of dimensions remains unchanged at 2. The shape, however, becomes (3,3).

Load the file into a NumPy array, excluding the header, and print the array.

Load the array instead using the compound type. Print the new array.

Convert the array you created in Exercise 6-2 to a recarray, and print out a list of the student numbers using the ‘array.field’ notation.

Get a list of (only) the scores of the 1^st student.

Print out student IDs of the 1^st two students.

Modify the score of the 2^nd student in the second test to 87.

Print the scores of all students in the 3^rd test.

Modify the scores of all students in the 4^th test to 75.

Print the scores of the 2^nd student in the last two tests.

Modify the scores of all students in the 1^st test to 70.

Print the ID and scores of the last student.

Repeat the selection from Example 7-8 but assign it to the variable sub_arr. Change the first score of sub_arr to 77. Is this sub-selection a view? Confirm by printing both sub_arr and scores_array to see if the original array has also been modified.

sub_arr is a view, you can see that both arrays have been modified:

Retrieve an array of the scores only (no student id) and apply a conditional expression to return True|False for any scores over 80.

Perform element-wise addition (+) and multiplication (*) of the two arrays and print the results.

Does the matrix dot operation between the arrays result in a valid array? Print the result. Can you explain how the result was generated?

No. A dot operation on a 1x3 matrix with another 1x3 matrix results in a scalar value. This can be depicted as follows:

Using dot on two equal size 1-D arrays (n-vectors) performs a matrix dot-product (or scalar-product) operation. (This should not be confused with “scalar * array” or “array * array” arithmetic multiplication.) However, if one side of the dot operation in NumPy is a scalar value, then it will revert to “scalar * array”, or “array * array” multiplication if the vectors are of different size.

Perform element-wise comparison (greater than, less than, equal to) between the elements of these arrays. Print the result of each comparison.

Perform scalar division on the array a with the value 5. Print the resulting array. What is the dtype of the result?

Create a larger NumPy array b with dimensions (3, 3) containing random values. Then, add array a to b. Print the resulting array.

Note, your final result will vary depending on the random values generated in b. The result is determined by adding a ([1, 2, 3]) to each row of b.

What percentage of student scores are over 80?

Compute the mean and standard deviation of the NumPy array arr = np.array([1, 2, 3, 4, 5]).

Compute and print out the median and quartiles (25th and 75th percentiles) of the following NumPy array arr = np.array([10, 20, 30, 40, 50]).

Compute and print out the correlation coefficient between the two NumPy arrays x and y.

The correlation coefficient is very near to -1, therefore there is a strong negative correlation; as x increases, y decreases linearly.

Convert the array a = np.array([[1, 2], [3, 4]])

Is it possible to reshape the 2x2 array a = np.array([[1, 2], [3, 4]]) into a 4x1 array? If so what is the procedure? Assign this new array to variable b.

Flatten the arrays a and b from exercise 2, and combine them into a single 2x4 array assigned to c.

Use a rotate operation upon c to convert it into a 2x4 array.

Convert the 1-D array a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9]) into a 3x3 array sorted in reverse order.

The key is to reverse the array first:

Swap the case of the array ['Hello', 'WORLD', 'FROM', 'Python'] so that uppercase letters are converted to lowercase, and lower to upper.

Pad the array of numeric strings ['42', '97', '2005', '025'] with zeros, up to a width of 4.

Test whether the values in the array ['Los', 'Angeles', 'Year 2019'] consist only of alphabetic characters.

Find the length of each value in the previous array.