Introduction
In this lab, you will learn the fundamentals of NumPy's Universal Functions, commonly known as ufuncs. Ufuncs are a cornerstone of high-performance computing in Python, allowing you to perform fast, element-wise operations on entire arrays of data. We will cover basic arithmetic, the powerful concept of broadcasting, aggregation methods, and how to control the data types of your results. By the end of this lab, you will be able to use ufuncs to write cleaner and more efficient data processing code.
Basic Arithmetic with Ufuncs
At their core, ufuncs perform element-wise operations. This means that when you apply an operation to two arrays, the operation is performed on each pair of corresponding elements. The most common ufuncs are the standard arithmetic operators like +, -, *, and /.
Let's start by performing a simple addition on two NumPy arrays.
First, open the file ufunc_examples.py from the file explorer on the left. Replace the existing content with the following code. This code imports NumPy, creates two arrays, and adds them together.
import numpy as np
## Create two arrays
arr1 = np.array([0, 2, 3, 4])
arr2 = np.array([1, 1, -1, 2])
## The '+' operator is a ufunc that adds the arrays element-wise
result = arr1 + arr2
## Print the result
print("Step 1 Result:")
print(result)
After adding the code, save the file. Now, run the script from the terminal to see the output.
python ufunc_examples.py
You should see the result of the element-wise addition.
Step 1 Result:
[1 3 2 6]
This demonstrates the fundamental behavior of a ufunc: arr1[0] is added to arr2[0], arr1[1] to arr2[1], and so on, producing a new array with the results.
Broadcasting in Action
Broadcasting is a powerful mechanism that allows NumPy to work with arrays of different shapes during arithmetic operations. Under the hood, NumPy "broadcasts" the smaller array across the larger array so that they have compatible shapes.
A common example is multiplying every element of an array by a single number. Let's also see a more complex case where a 1D array is broadcast across a 2D array.
Modify your ufunc_examples.py file. Add the following code to the end of the script.
## --- Appended code for Step 2 ---
## Broadcasting a scalar to an array
arr1 = np.array([1, 2, 3])
scalar_result = arr1 * 10
print("\nStep 2 Result (Scalar Broadcast):")
print(scalar_result)
## Broadcasting a 1D array to a 2D array
arr2d = np.array([[1], [2], [3]]) ## Shape (3, 1)
arr1d = np.array([1, 2, 3]) ## Shape (3,)
broadcast_result = arr2d * arr1d
print("\nStep 2 Result (Array Broadcast):")
print(broadcast_result)
Save the file and run it again from the terminal.
python ufunc_examples.py
You will see the output for both Step 1 and Step 2.
Step 1 Result:
[1 3 2 6]
Step 2 Result (Scalar Broadcast):
[10 20 30]
Step 2 Result (Array Broadcast):
[[1 2 3]
[2 4 6]
[3 6 9]]
In the second example, the 1D array arr1d (shape (3,)) and the 2D array arr2d (shape (3, 1)) are broadcast together to a common shape of (3, 3) before the element-wise multiplication happens.
Aggregating Arrays with .reduce()
Besides element-wise operations, ufuncs have special methods for performing aggregations. The .reduce() method is one of the most useful. It applies a ufunc repeatedly along a specified axis of an array until only one dimension is left.
For example, np.add.reduce(arr) is equivalent to np.sum(arr). Let's see how it works on a 2D array.
Append the following code to your ufunc_examples.py file.
## --- Appended code for Step 3 ---
## Create a 3x3 array
arr = np.arange(9).reshape(3, 3)
print("\nStep 3 Original Array:")
print(arr)
## Reduce the array by summing along axis 1 (the columns)
## This will sum the elements in each row.
## For row 0: 0 + 1 + 2 = 3
## For row 1: 3 + 4 + 5 = 12
## For row 2: 6 + 7 + 8 = 21
reduced_result = np.add.reduce(arr, axis=1)
print("\nStep 3 Result (reduce on axis=1):")
print(reduced_result)
Save the file and execute it.
python ufunc_examples.py
The output will now include the results from this step.
... (previous output) ...
Step 3 Original Array:
[[0 1 2]
[3 4 5]
[6 7 8]]
Step 3 Result (reduce on axis=1):
[ 3 12 21]
As you can see, .reduce() collapsed the array along the specified axis by applying the add operation to its elements.
Specifying Output Data Types
NumPy usually determines the data type of the output array automatically. However, you can explicitly specify the output data type using the dtype argument. This is useful for controlling memory usage or ensuring numerical precision.
Let's perform a reduction using multiplication and force the output to be a floating-point number, even though the input is an integer array.
Add the following code to the end of ufunc_examples.py.
## --- Appended code for Step 4 ---
## Use the same 3x3 array from Step 3
arr = np.arange(1, 10).reshape(3, 3) ## Using 1-9 to avoid multiplying by zero
print("\nStep 4 Original Array:")
print(arr)
## Reduce with multiplication, casting the output to float
## For row 0: 1 * 2 * 3 = 6
## For row 1: 4 * 5 * 6 = 120
## For row 2: 7 * 8 * 9 = 504
multiply_result = np.multiply.reduce(arr, axis=1, dtype=float)
print("\nStep 4 Result (multiply.reduce with dtype=float):")
print(multiply_result)
Save and run the script.
python ufunc_examples.py
Observe the output for Step 4.
... (previous output) ...
Step 4 Original Array:
[[1 2 3]
[4 5 6]
[7 8 9]]
Step 4 Result (multiply.reduce with dtype=float):
[ 6. 120. 504.]
Notice the trailing dots (.) in the output array [ 6. 120. 504.]. This indicates that the elements are now floating-point numbers, as we specified with dtype=float.
Overriding Ufunc Behavior
NumPy's ufunc system is extensible. You can create your own array-like objects that define how ufuncs should operate on them. This is an advanced feature typically done by subclassing NumPy's ndarray and overriding special methods like __add__ (for the + operator).
Let's create a simple custom array class that prints a message whenever addition is performed on it.
Add this final block of code to ufunc_examples.py.
## --- Appended code for Step 5 ---
## Define a custom array class by subclassing np.ndarray
class MyArray(np.ndarray):
def __add__(self, other):
print("\nStep 5: Custom add method called!")
## Call the original implementation from the parent class
return super().__add__(other)
## Create an instance of our custom class
## We must use .view() to cast the ndarray to our custom class
my_arr = np.array([10, 20, 30]).view(MyArray)
## Perform addition, which will trigger our custom method
override_result = my_arr + 5
print("Step 5 Result (Overridden Ufunc):")
print(override_result)
Save the file and run it one last time.
python ufunc_examples.py
Check the final output.
... (previous output) ...
Step 5: Custom add method called!
Step 5 Result (Overridden Ufunc):
[15 25 35]
You can see that our custom message was printed before the addition result, confirming that our __add__ method was called. This demonstrates the powerful flexibility of the ufunc system.
Summary
In this lab, you have learned the essentials of NumPy's Universal Functions (ufuncs). We started with basic element-wise arithmetic, which forms the foundation of vectorized computation. You then explored broadcasting, a key feature that allows NumPy to perform operations on arrays of different shapes. We also covered how to use ufunc methods like .reduce() for data aggregation and how to control the output data type with the dtype argument. Finally, you saw an advanced example of how to customize ufunc behavior by subclassing np.ndarray. With these skills, you are now better equipped to write efficient, readable, and powerful numerical code with NumPy.
