NumPy Array Fundamentals

Why NumPy? The Need for Speed

As someone with a background in computer science, you know that the choice of data structure can have a profound impact on performance. While Python lists are flexible, they are not optimized for the large-scale numerical computations required in machine learning. NumPy arrays provide a solution.

The key reasons for NumPy's efficiency are:

1. Fixed Data Type: All elements in a NumPy array must be of the same data type (e.g., all 64-bit integers or all 32-bit floats). This eliminates the type-checking overhead present in Python lists.
2. Contiguous Memory: NumPy arrays are stored in a single, continuous block of memory. This allows processors to access and manipulate the data very quickly, especially using SIMD (Single Instruction, Multiple Data) vector processing instructions. Python lists, in contrast, store pointers to objects scattered across memory.

To get a more detailed intuition behind these performance benefits, please watch the beginning of the following tutorial.

The ndarray: Anatomy of a NumPy Array

The fundamental object in NumPy is the ndarray, which stands for "N-dimensional array". It's a grid of values, all of the same type, indexed by a tuple of non-negative integers.

Let's look at what these arrays look like.

The number of dimensions is known as the rank of the array. The shape of an array is a tuple of integers giving the size of the array along each dimension.

• A 1D array (or vector) has a shape like (n,).
• A 2D array (or matrix) has a shape like (m, n).
• A 3D array (or tensor) has a shape like (d, m, n).

For a more formal definition of the ndarray and its characteristics, the official NumPy documentation is the best source.

Creating NumPy Arrays

Now that you understand what an array is, let's create some. The most common way to get started is by converting a Python list.

Creating Arrays from Lists

You can create an array by passing a list (or a list of lists) to the np.array() function. As a convention, NumPy is almost always imported with the alias np.

import numpy as np

# Create a 1D array (vector)
a1 = np.array([1, 2, 3, 4, 5])
print(f"1D Array:\n{a1}\n")

# Create a 2D array (matrix) from a list of lists
a2 = np.array([[1, 2, 3], [4, 5, 6]])
print(f"2D Array:\n{a2}\n")

# Create a 3D array from nested lists
a3 = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(f"3D Array:\n{a3}")

Using Array Creation Functions

Manually typing out large arrays is impractical. NumPy provides several functions to create arrays from scratch.

• np.zeros(shape): Creates an array of the given shape, filled with zeros.
• np.ones(shape): Creates an array filled with ones.
• np.full(shape, fill_value): Creates an array filled with a specific value.
• np.arange(start, stop, step): Creates an array with a range of evenly spaced values, similar to Python's built-in range().
• np.linspace(start, stop, num): Creates an array with a specified number of evenly spaced values over an interval.
• np.random.rand(d0, d1, ...): Creates an array of a given shape with random values from a uniform distribution over [0, 1).
• np.random.randint(low, high, size): Creates an array of a given size with random integers from a specified range.

The following video demonstrates these functions in action.

Inspecting Your Arrays

Once you have an array, you'll often need to check its properties. The most important attributes are:

• .ndim: The number of dimensions (axes).
• .shape: A tuple representing the dimensions of the array.
• .size: The total number of elements in the array.
• .dtype: The data type of the elements in the array.

# Create a 2x3 array of random integers between 10 and 99
data = np.random.randint(10, 100, size=(2, 3))

print(f"Array:\n{data}\n")
print(f"Number of dimensions (ndim): {data.ndim}")
print(f"Shape of array (shape): {data.shape}")
print(f"Total elements (size): {data.size}")
print(f"Data type (dtype): {data.dtype}")

import numpy as np

# Using np.full()
my_array = np.full((3, 4), 7.5)

# Alternatively, using np.ones() and multiplication
# my_array = np.ones((3, 4)) * 7.5

print(f"Array:\n{my_array}\n")
print(f"Shape: {my_array.shape}")
print(f"Data type: {my_array.dtype}")

Manipulating Arrays

Creating arrays is just the first step. The real power of NumPy comes from being able to efficiently access and manipulate the data within them.

Indexing and Slicing

Accessing elements works much like Python lists, but extends to multiple dimensions.

• Indexing: For a 2D array, you use arr[row, column].
• Slicing: You can slice along each dimension using the start:stop:step syntax. arr[0, 1:4] would get the first row and columns 1, 2, and 3. A colon : by itself means "select all elements along this axis."

This video provides a great hands-on demonstration of accessing elements in 2D and 3D arrays.

A crucial point about slicing: NumPy slices create views, not copies. This means a slice is a view into the original array's data. Modifying the slice will modify the original array. This is done for performance reasons. If you need a separate copy, you must explicitly use the .copy() method.

original = np.array([10, 20, 30, 40, 50])
print(f"Original array: {original}")

# Create a slice (a view)
a_slice = original[1:4] # Elements at index 1, 2, 3 -> [20, 30, 40]
print(f"Slice: {a_slice}")

# Modify an element in the slice
a_slice[0] = 99
print(f"Modified slice: {a_slice}")

# The original array is also changed!
print(f"Original array after modification: {original}")

# To create a copy, use the .copy() method
a_copy = original[1:4].copy()
a_copy[0] = 77
print(f"Original array is unaffected by copy modification: {original}")

Reshaping and Stacking

Often, you'll need to change the shape of your data to fit the requirements of a machine learning model.

• arr.reshape(new_shape): Returns a new array with a different shape, without changing the data. The new shape must have the same total number of elements (size).
• np.vstack((arr1, arr2)): Stacks arrays vertically (row-wise).
• np.hstack((arr1, arr2)): Stacks arrays horizontally (column-wise).

import numpy as np
data = np.arange(1, 13).reshape(3, 4)
print(data)
# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]

Conclusion

Congratulations on completing your first lesson on NumPy! You've taken a significant step from general-purpose Python programming into the world of specialized data science tools.

Key Takeaways:

• NumPy's ndarray is a powerful and efficient data structure for numerical computation, thanks to its use of contiguous memory and fixed data types.
• You can create arrays from Python lists using np.array() or from scratch with functions like np.zeros, np.ones, np.arange, and np.random.randint.
• Every array has important attributes like .shape, .size, and .dtype that allow you to inspect its structure.
• Array manipulation is done through indexing and slicing. Remember that slices create views, not copies, to conserve memory.
• You can change an array's structure with reshape() and combine arrays with vstack() and hstack().

Preview of the Next Lesson:
Now that you can create and structure arrays, the next logical step is to perform calculations with them. In our next lesson, we will explore element-wise operations and broadcasting. Broadcasting is a powerful mechanism that allows NumPy to perform arithmetic operations on arrays of different shapes, and it is a concept you will use constantly in machine learning.