Python NumPy Tutorial

Create arrays from lists or with helper functions:

import numpy as np
passengers = np.array([[8, 10, 7], [12, 6, 9]])
print(passengers.shape, passengers.ndim, passengers.size, passengers.dtype)
# (2, 3) 2 6 int64
zeros = np.zeros((3, 4))           # 3 rows of 4 zeros
steps = np.arange(0, 10, 2)        # [0 2 4 6 8]
grid = np.arange(6).reshape(2, 3)  # [[0 1 2] [3 4 5]]

• shape gives the size of each dimension as a tuple: (rows, columns) for a 2-D array.
• dtype is the element type. Every element has the same one, chosen from the data (int64, float64, bool...). The default integer size can differ by platform.
• reshape() changes the shape without changing the data; the total size must stay the same.

Index 2-D arrays with array[row, column]: passengers[1, 0] is 12, passengers[0] is the first row and passengers[:, 2] is the third column. Operations between arrays need compatible shapes; combining a (2, 3) array with a (2, 2) one raises ValueError: operands could not be broadcast together.

Arithmetic and comparisons apply element by element to whole arrays:

fares = np.array([4.5, 4.5, 6.0])
print(fares * 1.1)                 # [4.95 4.95 6.6 ]
print(passengers * fares)          # revenue per departure, per day
print(passengers > 8)              # boolean array of the same shape

This is called vectorization. The loop still happens, but inside NumPy's compiled code rather than in Python, which is typically tens to hundreds of times faster for large arrays. Functions such as np.sqrt, np.round, np.maximum and np.where work the same way.

Vectorization changes how you write the calculation, not what it means. passengers * fares gives the same numbers as a nested loop multiplying each count by its fare; it's just shorter and faster. If a calculation is hard to express with array operations, a clear loop is still acceptable for small data.

A boolean array can filter another array: passengers[passengers > 8] returns [10 12 9], the counts above 8. Combine conditions with & and |, with brackets: passengers[(passengers > 6) & (passengers < 10)].

Reductions such as sum, mean, min and max can work on the whole array or along an axis:

passengers = np.array([[8, 10, 7],
                       [12, 6, 9]])
print(passengers.sum())          # 52: everything
print(passengers.sum(axis=0))    # [20 16 16]: down each column
print(passengers.sum(axis=1))    # [25 27]: across each row

axis=0 collapses the rows, giving one result per column; axis=1 collapses the columns, giving one result per row. A helpful way to remember it: the axis you name is the one that disappears from the shape. (2, 3) summed over axis 0 becomes shape (3,).

Mixing up the axis produces numbers that look plausible but answer the wrong question, such as totals per departure when you wanted totals per day. Check the result's shape, and label results clearly when you print or chart them.

Basic slicing returns a view: a new array object that shares the original's data. Changing the view changes the original:

week = np.array([8, 10, 7, 12, 6])
first_three = week[:3]          # a view
first_three[0] = 99
print(week)                     # [99 10  7 12  6]

safe = week[:3].copy()          # independent data
safe[0] = 0
print(week[0])                  # still 99

Views make slicing fast and memory-efficient, but surprise people used to lists, where slicing copies. Call .copy() when you need to modify a part without affecting the whole.

Fancy indexing, with a list of positions or a boolean mask such as week[[0, 2]] or week[week > 8], always returns a copy. reshape() returns a view when it can. np.shares_memory(a, b) tells you whether two arrays share data, which is handy while learning.

Task: analyse a passenger grid with shape checks, row and column reductions and a view versus copy comparison.

import numpy as np

grid = np.array([[5, 9, 4, 8], [7, 3, 6, 10]])
assert grid.shape == (2, 4)

print("Day totals:", grid.sum(axis=1))          # [26 26]
print("Departure totals:", grid.sum(axis=0))    # [12 12 10 18]
print("Busiest departure:", grid.sum(axis=0).argmax())   # 3

view = grid[0]
copy = grid[0].copy()
view[0] = 0
print(grid[0, 0], copy[0])                      # 0 5

argmax() returns the position of the largest value. Changing the view altered grid, while the copy kept the original 5. For the worked check, axis=1 sums the values within each row, producing one total per row.

The official NumPy absolute beginner's guide and broadcasting guide go further. Continue with the pandas tutorial and Matplotlib tutorial. Practise with the Python exercises and Python quiz.