Master NumPy: Visual Guide to Multidimensional Arrays and Operations

NumPy is a foundational Python library that supports large multi‑dimensional arrays and matrix operations, essential for many machine‑learning and scientific‑computing projects. This article provides an intuitive, visual introduction to common NumPy functions and concepts, helping readers understand the internal mechanics of array manipulation.

NumPy serves as the basis for many popular Python data‑processing libraries such as pandas, PyTorch, TensorFlow, and Keras. Understanding NumPy’s behavior improves proficiency with these tools, and NumPy code often runs on GPUs with little or no modification.

The core concept of NumPy is the n‑dimensional array. Operations look the same regardless of dimensionality, though one‑ and two‑dimensional cases have special considerations. The article is divided into three parts: vectors (1‑D arrays), matrices (2‑D arrays), and higher‑dimensional arrays.

1. NumPy Arrays vs. Python Lists

At first glance NumPy arrays resemble Python lists: both act as containers that allow fast element access and assignment, but inserting or removing elements is slower.

The most obvious advantage of NumPy arrays is vectorized arithmetic:

Additional benefits include:

More compact storage, especially for dimensions greater than one.

Faster execution when operations can be vectorized.

Slower appends compared to lists.

Homogeneous element types enable high performance.

Here O(N) indicates time proportional to array size, while O*(1) (amortized O(1)) means time is generally independent of size.

2. Vectors: One‑Dimensional Arrays

2.1 Vector Initialization

One way to create a NumPy array is to convert a Python list; the array dtype is inferred from the list elements.

All elements must be of the same type; otherwise the array gets dtype='object', which hurts performance.

NumPy arrays cannot grow like Python lists because there is no extra space at the end. Common practice is to build a list first and convert it, or pre‑allocate space with np.zeros or np.empty :

Functions that create arrays filled with constant values follow the _like naming pattern:

Two functions generate monotonic sequences: np.arange and np.linspace . np.arange(3).astype(float) produces [0., 1., 2.] . np.arange is type‑sensitive: integer arguments yield integers, float arguments yield floats.

Floating‑point steps can cause rounding errors; np.linspace avoids this by specifying the number of points, though its num argument is often one larger than expected.

Random arrays are generated with functions such as np.random.rand :

2.2 Vector Indexing

NumPy provides several indexing methods. "View" indexing returns a view that shares data with the original array, while "fancy indexing" returns a copy that can be assigned to modify the original.

Boolean indexing allows logical conditions to select elements:

Note: chained comparisons like 3<=a<=5 are not supported.

Common functions for boolean indexing include np.where and np.clip :

2.3 Vector Operations

NumPy accelerates arithmetic by executing operations in compiled C code, eliminating slow Python loops. Scalars broadcast to arrays, and most mathematical functions have vectorized equivalents.

Broadcasting converts scalars to arrays during operations.

Vectorized trigonometric functions, rounding, and basic statistics are also available:

NumPy also provides basic statistical functions and sorting (though sorting is less feature‑rich than Python’s sorted ).

3. Matrices: Two‑Dimensional Arrays

The dedicated matrix class is deprecated; the article uses "matrix" and "2‑D array" interchangeably.

Matrix initialization mirrors vector syntax, but requires double brackets to specify rows:

Random matrix generation follows the same pattern as vectors:

Two‑dimensional indexing is more convenient than nested lists:

Views share data; modifications to the original array affect the view.

3.1 axis Parameter

Many functions (e.g., sum ) need to know whether to operate across rows or columns. axis=0 operates column‑wise, axis=1 row‑wise.

3.2 Matrix Arithmetic

Element‑wise operators ( +, -, *, /, //, ** ) work as usual, and the @ operator performs matrix multiplication.

Broadcasting extends to mixed vector‑matrix operations.

3.3 Row and Column Vectors

In 2‑D context, a one‑dimensional array is treated as a row vector. Column vectors can be created with reshape(-1, 1) or np.newaxis :

The three vector types (1‑D, 2‑D row, 2‑D column) can be transformed among each other.

3.4 Matrix Operations

Stacking functions: np.hstack , np.vstack , and np.column_stack . vstack works when mixing 1‑D arrays and matrices; hstack requires matching dimensions.

Splitting reverses stacking, and duplication can be done with np.tile or np.repeat .

Rows/columns can be removed with np.delete and inserted with np.insert . Simple padding can be achieved with np.pad .

3.5 Grids

Broadcasting simplifies grid operations. Instead of materializing full index matrices, store one‑dimensional vectors and rely on broadcasting.

NumPy’s np.meshgrid creates coordinate matrices; np.mgrid creates dense grids; np.indices generates full index arrays; np.fromfunction calls a function once.

3.6 Matrix Statistics

Functions like min , max , argmin , argmax , mean , std , var support the axis argument.

For multi‑dimensional argmin / argmax , np.unravel_index converts flat indices to coordinates.

np.all and np.any also accept axis .

3.7 Matrix Sorting

The axis argument does not affect sorting; instead, use argsort or np.lexsort for column‑wise or multi‑column sorting.

Examples:

<code>a = a[a[:,0].argsort()]  # sort by first column
a = a[a[:,2].argsort()]
a = a[a[:,1].argsort(kind='stable')]
a = a[a[:,0].argsort(kind='stable')]
</code>

For full multi‑column sorting, np.lexsort can be used, though it sorts rows in reverse order. Pandas often provides a more convenient interface:

<code>pd.DataFrame(a).sort_values(by=[2,5]).to_numpy()
</code>

4. Three‑Dimensional and Higher Arrays

When creating a 3‑D array from reshaped vectors or nested lists, the index order is (z, y, x): first the plane number, then the row and column within that plane.

For RGB images, the common order is (y, x, z) where the last axis is the color channel. np.concatenate with an explicit axis argument handles arbitrary layouts better than hstack/vstack/dstack .

Transposing swaps axes; the default a.T does not match either (z, y, x) or (y, x, z) conventions.

The einsum (Einstein summation) function provides concise notation for complex reductions and can be faster than np.tensordot in advanced cases.

Source

https://mp.weixin.qq.com/s/ov14T51pEE5GxqLAvyiasg