NumPy Arithmetic Operations

Element-wise arithmetic

NumPy operations between equal-size arrays apply the operation element-wise — this is what the book calls “vectorization,” and it’s what lets you skip writing for loops.

elementwise

import numpy as np
 
a = np.array([1, 2, 3])
b = np.array([10, 20, 30])
 
print(a + b)
print(a - b)
print(a * b)
print(a / b)

Scalar operations

Arithmetic with a scalar propagates that value to every element in the array (this is broadcasting in its simplest form).

scalar

import numpy as np
 
arr = np.array([1, 2, 3])
print(arr * 10)
print(arr + 0.5)

Power and modulo

power

import numpy as np
 
arr = np.array([2, 3, 4])
print(arr ** 2)  # [4 9 16]
print(arr % 2)   # [0 1 0]

Comparisons

Comparisons produce boolean arrays, applied element-wise just like arithmetic.

compare

import numpy as np
 
arr = np.array([10, 20, 30])
print(arr > 15)       # [False True True]
print(arr == 20)      # [False True False]

diagram Same array, four kinds of results mermaid

  flowchart LR
  A["Two equal-shape arrays"] --> B["Arithmetic (+ - * /)
-> same-shape array"]
  A --> C["Comparison (> == <)
-> boolean array"]
  A --> D["Aggregation (.sum/.mean)
-> scalar or lower-dim array"]
  E["Two 2D arrays"] --> F["Matrix multiply (@)
-> new matrix, NOT element-wise"]

Arithmetic, comparison, and aggregation all start from the same element-wise machinery but end in different shapes.

Aggregations (sum, mean, min, max)

agg

import numpy as np
 
mat = np.array([
    [1, 2, 3],
    [4, 5, 6]
])
 
print(mat.sum())          # sum of all
print(mat.sum(axis=0))    # column sums
print(mat.sum(axis=1))    # row sums
 
print(mat.mean(axis=0))
print(mat.min(axis=1))
print(mat.max(axis=1))

From the book

Read axis=0 as “collapse the rows, keep one value per column” and axis=1 as “collapse the columns, keep one value per row.” So mat.sum(axis=0) is a column-wise sum, and mat.sum(axis=1) is a row-wise sum — the axis you name is the one that disappears.

Matrix multiplication vs element-wise multiplication

Element-wise multiplication

* multiplies matching positions — it is not the same as matrix multiplication.

mul

import numpy as np
 
a = np.array([[1, 2], [3, 4]])
b = np.array([[10, 20], [30, 40]])
print(a * b)

Matrix multiplication

Use @ operator or np.matmul.

matmul

import numpy as np
 
a = np.array([[1, 2], [3, 4]])
b = np.array([[10, 20], [30, 40]])
print(a @ b)

Rounding

rounding

import numpy as np
 
arr = np.array([1.234, 5.678])
print(np.round(arr, 2))
print(np.floor(arr))
print(np.ceil(arr))

Next

Continue to: NumPy Universal Functions (ufuncs) to learn fast built-in vectorized functions.

🧪 Try It Yourself

Exercise 1 – Element-wise vs Matrix Multiplication

pch.exerciseTag pch.exerciseTitle

Exercise 2 – Sum Along an Axis

pch.exerciseTag pch.exerciseTitle

Exercise 3 – Round, Floor, Ceil

pch.exerciseTag pch.exerciseTitle