Arrays, dtypes, shapes and axes

A Python list is a row of pointers. Each entry points somewhere else in memory, each can be a different type, and the list can grow. That flexibility costs you: to add up a million of them, Python follows a million pointers and asks each object what addition means.

An array gives all of that up. It is one contiguous block of memory, every element the same type, in a fixed shape. Adding up a million of them is one loop in compiled code over adjacent bytes, with nothing to look up.

Everything else in this lesson follows from those three constraints:

• One type, so the type is decided when the array is made and applies to everything in it.
• Fixed shape, so appending means allocating a new block and copying.
• Contiguous, so a reshape is usually free and a transpose does not move anything.

The trade is deliberate. You lose the ability to hold anything you like, and you get arithmetic that runs at the speed of the machine rather than the speed of the interpreter.

The dtype is the type of every element. It is chosen once, when the array is created, and everything put in afterwards is converted to it.

When you build an array from Python numbers, NumPy picks a dtype wide enough to hold all of them:

np.array([1, 2, 3])        -> int64
np.array([1, 2.0, 3])      -> float64   one float makes them all float
np.array([True, False])    -> bool
np.array([True, 1])        -> int64     bool only survives on its own

That third and fourth line are the pair worth remembering. bool is kept only when everything is a bool; a single integer in the list and the whole array is integer.

You can also say what you want, and then you get exactly that:

np.array([1, 2, 3], dtype=np.float32)   -> float32

Which matters, because the dtype decides how much memory the array takes and how much precision it keeps. A float32 array is half the size of a float64 one and carries about seven decimal digits instead of sixteen.

The shape is a tuple with one entry per axis, saying how long that axis is. From it come the other two: ndim is how many axes there are, and size is how many elements in total.

[[1, 2, 3],
 [4, 5, 6]]        shape (2, 3)   ndim 2   size 6

To read a shape off a nested literal, count from the outside in. The outermost list has two entries, so the first number is 2. Each of those has three, so the second is 3.

Two shapes are worth naming because they are constantly confused:

• (3,) is one-dimensional, three elements. That trailing comma is not decoration, it is what makes it a tuple.
• (3, 1) is two-dimensional, a column. Same three numbers, different object.

They hold the same data and behave differently in almost every operation, which is the single most common source of a shape bug.

Axes are numbered from the outside in: axis 0 is the first number in the shape, axis 1 the second, and so on. For a two-dimensional array, axis 0 runs down the rows and axis 1 runs across the columns.

Every reduction takes an axis, and people get it backwards constantly, so here is the rule that never fails:

The axis you name is the axis that disappears.

a.shape == (2, 3)

a.sum(axis=0)  -> shape (3,)     axis 0 is gone
a.sum(axis=1)  -> shape (2,)     axis 1 is gone
a.sum()        -> shape ()       all of them are gone

So axis=0 on a table of rows and columns sums down each column and leaves you one number per column. It reads like "sum the rows", which is why people expect the wrong answer.

If you want the axis to stay, as a length-one dimension, pass keepdims=True. (2, 3) reduced along axis 1 with keepdims is (2, 1) rather than (2,), which is often exactly what you need to divide by.

A reshape reinterprets the same block of memory under a new shape. The only rule is that the total number of elements cannot change:

a.shape == (2, 3, 4)      size 24

a.reshape(6, 4)      -> (6, 4)     24 elements
a.reshape(24)        -> (24,)      24 elements
a.reshape(5, 5)      -> error      25 is not 24

Because the total is fixed, one of the numbers is always redundant, and -1 asks NumPy to work it out:

a.reshape(6, -1)     -> (6, 4)
a.reshape(-1)        -> (24,)      the usual way to flatten

Only one dimension can be -1, because two unknowns and one equation has no single answer.

The order matters and it is worth knowing: NumPy fills in row-major order, meaning the last axis varies fastest. Reshaping (2, 3) to (3, 2) reads the elements out row by row and repacks them -- it is not a transpose, and the two give different answers.

Sometimes an array has the right numbers and the wrong rank. Two operations fix that without touching the data.

Adding one. np.newaxis (which is just None) inserts a length-one axis wherever you put it:

a.shape == (3,)

a[np.newaxis, :]  -> (1, 3)    a row
a[:, np.newaxis]  -> (3, 1)    a column

Dropping them. squeeze removes length-one axes:

b.shape == (1, 3, 1)

b.squeeze()        -> (3,)     every length-one axis
b.squeeze(axis=0)  -> (3, 1)   just that one

A length-one axis holds no extra numbers, so this looks like bookkeeping. It is not. The difference between (3,) and (3, 1) decides whether two arrays can be combined at all, and turning one into the other is how you make an operation line up the way you meant.