Building an array by hand

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

b = np.array([[0, 1, 2, 3, 4],
              [5, 6, 7, 8, 9]], dtype=float)

c = np.array([[1, 6], [2, 7], [3, 8],
              [4, 9], [5, 10]], dtype=int)

Nested lists become extra dimensions. b is a list of two 5-element lists, so it is a 2×5 array. c is a list of five 2-element lists, so it is 5×2.

dtype fixes the type of every element. Unlike a Python list, an array cannot mix ints and strings — and that restriction is exactly what makes it fast.

Four questions, four attributes

c.dtype   # int64   type of each element
c.shape   # (5, 2)  length of each dimension
c.ndim    # 2       number of dimensions
c.size    # 10      total number of elements

shape is the one you will type a hundred times this semester. ndim == len(shape) and size == prod(shape), always.

dtype=int means the platform default — int64 on Linux and macOS, int32 on Windows. Say np.int64 when the width has to be guaranteed.

Changing type

a.astype(np.float16)
b.astype(np.int8)      # 7.0 -> 7, truncates

astype returns a new array. Converting float to int truncates toward zero — it does not round.

Negative makes it worse

A negative index is not an error signal — it counts from the end. So arithmetic that should have been rejected produces a perfectly legal slice somewhere else in the array.

start = (5 - 9) // 2   # -2
a[start:start + 9]     # array([3, 4])

Nine elements were asked of a five-element array. The answer came back with two, taken from the opposite end.

When it bites: every "why is my array the wrong size" bug. The slice was legal — it just was not the one you meant. Any time a slice bound is computed rather than typed, this is live.

A slice is a window, not a photograph

Slicing an array gives you a view — a second way of looking at the same memory. Write through the view and the original changes underneath you.

b = np.array([[0,1,2,3,4],
              [5,6,7,8,9]], dtype=float)
row = b[0]        # a view, not a copy
row[0] = 99
print(b[0, 0])

The fix: make a copy

aa = a.copy()     # deep copy, independent memory
aa.fill(0)
print(a)
print(aa)

When it bites: you crop a region out of an image, adjust its brightness, and later discover the full-size image has a bright rectangle in it.

Rule of thumb: slicing and reshaping give views; fancy/boolean indexing, astype and arithmetic give new arrays. When in doubt, .copy() — it is cheap compared to the debugging.

Same numbers, different shape

b.ravel()            # -> (10,)   a view if it can
b.flatten()          # -> (10,)   always a copy
b.reshape(5, 2)      # -> (5, 2)
np.resize(b, (6,2))  # -> (6, 2)  b is (2, 5)

Use -1 for one dimension and NumPy infers it: b.reshape(-1, 2).

Stacking and splitting

np.concatenate((b, b+10), axis=0)   # (4, 5)
np.concatenate((b, b+10), axis=1)   # (2, 10)

np.r_[b, b+10]      # shorthand for axis=0
np.c_[b, b+10]      # shorthand for axis=1

np.split(b, 2, axis=0)   # list of 2 sub-arrays

axis=0 means "grow downward, along the rows". axis=1 means "grow sideways, along the columns". Every other axis must already match.

np.r_ and np.c_ use square brackets because they are indexing objects, not functions. Convenient, but spell out concatenate when the reader needs to see the axis.

Arithmetic is element-wise

a = np.array([0, 1, 2, 3, 4])
d = np.array([5, 6, 7, 8, 9])

a + d     # np.add
a - d     # np.subtract
a * d     # np.multiply
a / d     # np.divide

No loops. The operation is applied to every position independently and the result has the same shape.

* is not matrix multiplication — it multiplies element by element. For matrix products use @. This trips up people arriving from MATLAB.

Collapsing an array to a summary

b.sum()    # 45.0    everything
b.min()    # 0.0
b.max()    # 9.0
b.mean()   # 4.5

The axis argument

b.sum()          # 45.0   a scalar
b.sum(axis=0)    # [ 5.  7.  9. 11. 13.]
b.sum(axis=1)    # [10. 35.]

axis=k is the axis that disappears. Summing a (2, 5) array over axis 0 leaves shape (5,) — five numbers, one per column. Over axis 1 you get (2,), one per row.

Those trailing dots are not decoration — b was built with dtype=float, and the repr tells you so. Reading dtype off the output is a free habit.

Comparison

a == a     # [True True True True True]
b < 2      # a (2,5) array of booleans

Comparisons are element-wise too, so they give you an array — which means if a == b: raises "truth value of an array is ambiguous".

np.array_equal(a, b)   # False

Not the axis you keep

Almost everyone first reads axis=0 as "work along the rows". It means the opposite: axis 0 is collapsed, and everything else survives.

b.shape                # (2, 5)
b.sum(axis=0).shape    # (5,)   axis 0 is gone
b.sum(axis=1).shape    # (2,)   axis 1 is gone

Map it straight onto the shape tuple: axis=k deletes the k-th number from shape. That one sentence settles nearly every axis question you will have this semester.

On an image, both are legal

img.shape             # (512, 768, 3)
img.mean(axis=2)      # (512, 768)  grey per pixel
img.mean(axis=(0,1))  # (3,)  mean per channel

Both are "the mean of the image". They answer entirely different questions, and choosing wrong gives you a perfectly valid array instead of an error.

Linear algebra

b.T                # transpose, (2,5) -> (5,2)
a.dot(a)           # dot product -> 30
b @ c              # (2,5) @ (5,2) -> (2,2)
x = c.T @ c
np.linalg.inv(x)   # inverse
b.trace()          # sum of the diagonal
np.eye(3)          # identity

Inner dimensions must agree: (2,5) @ (5,2) works, (2,5) @ (2,5) does not. Read the error message — it prints both shapes and tells you exactly which pair failed.

You will need this for homogeneous coordinates and camera matrices in a fortnight.

Universal functions

np.exp(a)
np.sin(a)
np.log(c)
np.abs(-b)
np.power(b, 3)

A ufunc applies a scalar function to every element and returns an array of the same shape — the same pattern as arithmetic, with a name.

A plot in six lines

x   = np.arange(-2, 2, 0.1)
y_1 = np.power(x, 2)
y_2 = -np.power(x, 2)

plt.plot(x, y_1, label=r'$x^2$')
plt.plot(x, y_2, label=r'$-x^2$')

plt.xlabel('x axis')
plt.ylabel('y axis')
plt.title('parabola')
plt.legend()
plt.show()

This is the stateful interface: every call acts on the current figure. Fine for a worksheet. For anything you will reuse, fig, ax = plt.subplots() and calling methods on ax is easier to reason about.

An image is an ndarray

import os
rootpath = './'
path = os.path.join(rootpath, "kodim23.png")
bird = cv2.imread(path)

type(bird)
bird.shape
bird.dtype

Row before column. The origin is the top-left corner and the row index increases downward — the opposite of a maths y-axis.

cv2.imread(path, cv2.IMREAD_GRAYSCALE) returns a 2D (512, 768) array instead — one channel, no axis 2 at all.

Interrogating pixels

image_rgb[100, 100, :]   # [255   0   0]  red
image_rgb[100, 200, :]   # [  0 255   0]  green
image_rgb[100, 300, :]   # [  0   0 255]  blue
image_rgb[  0,   0, :]   # [255 255 255]  white
image_rgb[226, 340, :]   # [  0   0   0]  black

Row first, then column, then channel — the same order as shape. White is all channels at maximum, black is all at zero.

This is the check to run whenever you are unsure which convention an array is in. Point at a pixel whose colour you already know and read the numbers.

One channel at a time

imshow(bird[:, :, 0])   # blue  (BGR!)
imshow(bird[:, :, 1])   # green
imshow(bird[:, :, 2])   # red

Each is a 2D array shown in grayscale — lighter means a higher value. Look at the sky: bright in blue, dark in red. Indexing with an integer drops the channel axis, so bird[:,:,0].shape is (512, 768), which is why the helper has a grayscale branch.

The one that flips your image

shape gives (height, width). cv2.resize takes (width, height) — the opposite order. Read the shape tuple, hand it straight to resize, and you have transposed the picture.

img.shape             # (300, 400, 3)

wrong = cv2.resize(img, (300, 400))
wrong.shape           # (400, 300, 3)  flipped

The shape tuple went straight in, so resize read 300 as the width and 400 as the height. A 300×400 image came back standing on its end — and no exception, because that is what it was asked for.

h, w = img.shape[:2]
right = cv2.resize(img, (w, h))   # width first

Why it hides

On a square image the two orders are identical, so it works on your test picture and fails on the real dataset. On a non-square image you get a valid, wrongly-proportioned result and no error at all.

The exercise's 224×224 target is square, so it will not catch this. The 128×156 crop is not — that one will.

Getting pixels back out

out = os.path.join(rootpath, "resize_bird.jpeg")
cv2.imwrite(out, resize_img3)

test = cv2.imread(out)
print(test.shape, test.dtype)
imshow(test)

The file extension picks the encoder — .png, .jpeg, .tif. There is no format argument.

imwrite expects BGR, the same order imread gave you. If you converted to RGB for display, convert back before saving or your saved file will have the channels swapped.

Where the bright speckles come from

An image is uint8. Every value gets exactly 8 bits, and NumPy will not widen the type to fit your answer — it wraps.

green = np.uint8([200])
blue  = np.uint8([180])

green + blue
(green + blue) // 2

No warning, no error. Averaging two bright pixels hands back a dark one, so the damage lands exactly where the picture was brightest.

Widen, compute, come back

wide = green.astype(np.uint16)
avg = (wide + blue) // 2
red = avg.astype(np.uint8)

Anything that can leave 0–255 — brightening, scaling contrast, differencing two frames — needs clipping before the cast back:

out = np.clip(x, 0, 255).astype(np.uint8)

When it bites: step 4 of today's exercise, the moment you reach for (g + b) // 2.

NumPy

• NumPy: the absolute basics for beginners — the official starting point.
• Scientific Python Lectures, NumPy chapter — covers today's material in more depth. CC BY 4.0.
• Rougier, NumPy tutorial — excellent diagrams for slicing. CC BY-SA 4.0.
• 100 NumPy exercises — practice, with solutions. MIT.
• Stanford CS231n Python/NumPy tutorial — the best short explanation of broadcasting.

Matplotlib

• Official cheatsheets — print the beginner handout and keep it next to you.
• Quick start guide — figure and axes explained properly.

Images

• OpenCV-Python tutorials — the reference for every function used today.
• Data Carpentry: Image Processing with Python — pixels, coordinates and colour models from scratch. CC BY 4.0.

Diagrams in this deck are original. Course content follows the COMP90086 Workshop 2 worksheet.