Once you have your data loaded into NumPy arrays, the next logical step is performing computations. A primary reason for NumPy's popularity in scientific computing and machine learning is its ability to perform fast, vectorized operations on entire arrays without the need for explicit Python for loops. Here, we analyze how NumPy handles array mathematics and introduce the concept of Universal Functions (ufuncs).
Standard Python arithmetic operators work directly on NumPy arrays, performing operations element by element. This is a fundamental feature that distinguishes NumPy arrays from Python lists.
Consider two arrays:
import numpy as np
arr1 = np.array([1, 2, 3, 4])
arr2 = np.array([10, 20, 30, 40])
# Element-wise addition
print(arr1 + arr2)
# Output: [11 22 33 44]
# Element-wise subtraction
print(arr2 - arr1)
# Output: [ 9 18 27 36]
# Element-wise multiplication
print(arr1 * arr2)
# Output: [ 10 40 90 160]
# Element-wise division
print(arr2 / arr1)
# Output: [10. 20. 30. 40.]
# Element-wise exponentiation
print(arr1 ** 2)
# Output: [ 1 4 9 16]
These operations create new arrays containing the results. The operations are performed between corresponding elements of the arrays. This element-wise behavior also applies to comparisons:
arr1 = np.array([1, 5, 3, 7])
arr2 = np.array([2, 4, 3, 8])
# Element-wise comparison
print(arr1 > arr2)
# Output: [False True False False]
print(arr1 == arr2)
# Output: [False False True False]
These comparisons return boolean arrays, which are useful for indexing and conditional logic, as we'll see later.
The main benefit here is performance. NumPy's operations are implemented in C and operate on blocks of memory, making them significantly faster than iterating through Python lists with loops for numerical computations.
While standard operators are convenient, NumPy provides a richer set of mathematical functions through its Universal Functions, or ufuncs. A ufunc is a function that performs element-wise operations on data in ndarray objects. Think of them as vectorized wrappers for simple functions that take one or more scalar inputs and produce one or more scalar outputs.
Ufuncs can be broadly categorized:
These functions operate on a single array, performing the operation on each element.
arr = np.arange(1, 6) # Creates [1 2 3 4 5]
print(arr)
# Square root of each element
print(np.sqrt(arr))
# Output: [1. 1.41421356 1.73205081 2. 2.23606798]
# Exponential (e^x) of each element
print(np.exp(arr))
# Output: [ 2.71828183 7.3890561 20.08553692 54.59815003 148.4131591 ]
# Natural logarithm (log base e)
# Note: log(0) is -inf, log of negative numbers is nan
arr_pos = np.array([1, np.e, np.e**2])
print(np.log(arr_pos))
# Output: [0. 1. 2.]
# Sine of each element (assumes radians)
angles = np.array([0, np.pi/2, np.pi])
print(np.sin(angles))
# Output: [0.0000000e+00 1.0000000e+00 1.2246468e-16] # Note the floating point precision near 0
# Absolute value
arr_neg = np.array([-1, 2, -3.5])
print(np.abs(arr_neg))
# Output: [1. 2. 3.5]
Other common unary ufuncs include np.cos, np.tan, np.log10, np.ceil, np.floor, np.round, np.isnan (checks for Not a Number), and np.isinf (checks for infinity).
These functions take two arrays as input (though broadcasting, covered next, allows for compatible shapes) and perform the operation element-wise. Many binary ufuncs correspond to arithmetic operators.
arr1 = np.array([1, 5, 3, 8])
arr2 = np.array([2, 4, 3, 7])
# Element-wise addition (equivalent to arr1 + arr2)
print(np.add(arr1, arr2))
# Output: [ 3 9 6 15]
# Element-wise maximum
print(np.maximum(arr1, arr2))
# Output: [2 5 3 8]
# Element-wise minimum
print(np.minimum(arr1, arr2))
# Output: [1 4 3 7]
# Element-wise power (equivalent to arr1 ** arr2, sometimes)
# Use np.power for more complex base/exponent types if needed
print(np.power(arr1, arr2))
# Output: [ 1 625 27 2097152]
# Modulo / Remainder
print(np.mod(arr1, arr2)) # Equivalent to arr1 % arr2
# Output: [1 1 0 1]
Other useful binary ufuncs include np.subtract, np.multiply, np.divide, np.floor_divide, np.greater, np.less_equal, np.logical_and, np.logical_or, etc.
The efficiency of ufuncs becomes apparent with larger arrays. Let's compare calculating the sine of numbers from 0 to 999,999 using a Python loop versus a NumPy ufunc.
# Create a large array
large_arr = np.arange(1_000_000)
# Using a Python loop (for illustration - slow!)
import math
result_loop = [0.0] * 1_000_000 # Pre-allocate list
# %timeit for i in range(1_000_000): result_loop[i] = math.sin(large_arr[i])
# On typical hardware: ~200-300 ms per loop
# Using NumPy ufunc
# %timeit result_ufunc = np.sin(large_arr)
# On typical hardware: ~5-10 ms per loop
(Note: %timeit is an IPython magic command. If running in a standard Python script, you would use the timeit module for benchmarking.)
The NumPy ufunc is typically orders of magnitude faster because the looping occurs in highly optimized, compiled C code operating on contiguous blocks of memory, rather than interpreting Python code for each element. This speed is fundamental for processing the large datasets common in machine learning.
Often, you need to apply logic based on array values. Using boolean arrays generated by comparisons along with functions like np.where provides a powerful, vectorized way to achieve this, avoiding slow Python loops.
np.where is the vectorized equivalent of a ternary expression (x if condition else y). It takes three arguments: a condition (a boolean array), and two values or arrays ( and ). It returns a new array where elements are taken from where the condition is True, and from where the condition is False.
# Example data: measurement readings
readings = np.array([10, -5, 22, -8, 15, 0])
# Replace negative readings with 0, keep positive ones as is
cleaned_readings = np.where(readings < 0, 0, readings)
print(cleaned_readings)
# Output: [10 0 22 0 15 0]
# Assign categorical labels based on a threshold
threshold = 12
labels = np.where(readings > threshold, 'High', 'Low')
print(labels)
# Output: ['Low' 'Low' 'High' 'Low' 'High' 'Low']
# Using two arrays for x and y
arr_a = np.array([100, 200, 300, 400])
arr_b = np.array([1, 2, 3, 4])
condition = np.array([True, False, True, False])
result = np.where(condition, arr_a, arr_b)
print(result)
# Output: [100 2 300 4]
You can also perform aggregations on boolean arrays:
bool_arr = np.array([True, False, True, False])
# Check if any element is True
print(np.any(bool_arr))
# Output: True
# Check if all elements are True
print(np.all(bool_arr))
# Output: False
# Count the number of True elements (True evaluates to 1, False to 0)
print(np.sum(bool_arr))
# Output: 2
These conditional and aggregation tools allow for complex, array-based logic to be expressed concisely and executed efficiently.
Mastering array mathematics and ufuncs is essential for writing effective NumPy code. They allow you to express computations naturally and achieve high performance, forming the basis for more complex operations and interactions with libraries like Pandas and Scikit-learn. The next section looks at broadcasting, which extends these element-wise operations to arrays that don't have exactly the same shape.
Was this section helpful?
© 2026 ApX Machine LearningEngineered with