NumPy Array Fundamentals

Why Do We Need NumPy?

Before we dive into the code, it's important to understand why NumPy is so essential. As a computer science student, you know that the way data is stored in memory has a massive impact on performance.

Python lists are incredibly flexible—they can hold different data types (an integer, a string, another list) all in one place. This flexibility comes at a cost. The elements of a list are stored as separate objects in memory, with the list itself just holding pointers to these objects. This makes iterating over them for numerical calculations relatively slow.

NumPy arrays, on the other hand, are grids of values of the same type. They are stored in a contiguous block of memory. This homogeneity and memory locality allows NumPy to perform operations on the entire array at once (a concept called vectorization), often using highly optimized C or Fortran code under the hood. The result is a dramatic speedup, often by a factor of 10 to 100, and significantly less memory usage.

The NumPy ndarray Object

The fundamental object in NumPy is the N-dimensional array, or ndarray. It's a versatile data structure that can represent vectors (1D arrays), matrices (2D arrays), and higher-dimensional data structures often called tensors.

To get a formal introduction to the ndarray, let's turn to the official NumPy documentation.

Creating NumPy Arrays

Now, let's get our hands dirty and start creating arrays. First, you'll need to import the NumPy library. The standard convention, which you should always follow, is:

import numpy as np

1. Creating Arrays from Python Lists

The most straightforward way to create an array is by converting a Python list.

• 1D Array (Vector): Pass a simple list to np.array().
• 2D Array (Matrix): Pass a list of lists, where each inner list represents a row.

# Create a 1D array
list_1d = [1, 2, 3, 4, 5]
arr_1d = np.array(list_1d)
print("1D Array:")
print(arr_1d)

# Create a 2D array
list_2d = [[1, 2, 3], [4, 5, 6]]
arr_2d = np.array(list_2d)
print("\n2D Array:")
print(arr_2d)

The video below provides a great walkthrough of creating arrays from lists and other methods.

2. Using NumPy's Array Creation Functions

More often, you will create arrays from scratch using NumPy's built-in functions. These are highly efficient and convenient.

• np.arange(start, stop, step): Similar to Python's range(), but it returns a NumPy array and can use floating-point steps.
• np.zeros(shape): Creates an array of a given shape filled with zeros.
• np.ones(shape): Creates an array filled with ones.
• np.linspace(start, stop, num): Creates an array with num evenly spaced numbers over a specified interval [start, stop]. Given your calculus background, you can see how useful this is for generating points to evaluate and plot a function.

Let's see them in action.

# Create an array with values from 0 to 9
arr_arange = np.arange(10)
print(f"np.arange(10):\n{arr_arange}\n")

# Create a 3x4 matrix of zeros
# Note that the shape is passed as a tuple: (3, 4)
arr_zeros = np.zeros((3, 4))
print(f"np.zeros((3, 4)):\n{arr_zeros}\n")

# Create a 2x5 matrix of ones
arr_ones = np.ones((2, 5))
print(f"np.ones((2, 5)):\n{arr_ones}\n")

# Create 5 evenly spaced points from 0 to 1 (inclusive)
arr_linspace = np.linspace(0, 1, 5)
print(f"np.linspace(0, 1, 5):\n{arr_linspace}")

For a comprehensive review of these functions, the "Python for Beginners" book by Wes McKinney is an excellent reference.

# 1. The 2D array
matrix = np.array([[8, 1, 6],
                   [3, 5, 7],
                   [4, 9, 2]])
print("1. 2D array:\n", matrix)

# 2. Array of zeros
zeros_arr = np.zeros(20)
print("\n2. Array of zeros:\n", zeros_arr)

# 3. Array of even numbers
evens_arr = np.arange(10, 19, 2)
print("\n3. Array of even numbers:\n", evens_arr)

Inspecting Array Attributes

Once you have an array, you need to be able to inspect its properties. The three most fundamental attributes are shape, size, and dtype.

• .ndim: The number of dimensions (or axes) of the array.
• .shape: A tuple of integers indicating the size of the array in each dimension.
  • For a 1D array of 5 elements, the shape is (5,).
  • For a 2D array with 3 rows and 4 columns, the shape is (3, 4).
• .size: The total number of elements in the array. This is simply the product of the elements in the shape tuple.
• .dtype: An object describing the data type of the array's elements.

The following image provides a fantastic visual summary of these concepts.

Let's see this in code with the arrays we created earlier.

# Inspecting the 2D array from our previous example
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])

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

A Deeper Look at dtype

The dtype is particularly important. Because all elements in a NumPy array must have the same type, NumPy needs to know how much memory to allocate for each element.

• Type Inference: When you create an array from a list, NumPy tries to infer the most appropriate dtype. If all elements are integers, you'll likely get int64. If even one element is a float, the entire array will be cast to float64.
• Explicitly Setting dtype: You can (and often should) specify the dtype for memory efficiency. If you know your values will not exceed the range of a 32-bit integer, using np.int32 instead of the default np.int64 will cut the memory usage for that array in half.

This video segment explains the importance of dtype and memory efficiency very well.

Here is an example of explicitly setting the data type:

# Default dtype is int64 on most systems
arr_default = np.array([1, 2, 3])
print(f"Default dtype: {arr_default.dtype}")

# Explicitly setting a smaller integer type
arr_smaller = np.array([1, 2, 3], dtype=np.int8)
print(f"Specified dtype: {arr_smaller.dtype}")

# Creating an array of ones with float32 dtype
arr_float = np.ones((2, 2), dtype=np.float32)
print(f"Float dtype: {arr_float.dtype}")
print(arr_float) # Note the decimal points, indicating they are floats

Conclusion

Excellent work! You've just learned the most fundamental operations in NumPy: how to create the ndarray data structure and how to check its basic properties. This knowledge is the bedrock upon which all your future work in data science and AI will be built.

Key Takeaways:

• NumPy Arrays (ndarray) are efficient, fixed-size, homogeneous data structures that are much faster for numerical computation than Python lists.
• You can create 1D arrays from lists (np.array([1, 2, 3])) and 2D arrays from nested lists (np.array([[1, 2], [3, 4]])).
• Functions like np.arange(), np.linspace(), np.zeros(), and np.ones() are powerful tools for creating arrays from scratch.
• You can inspect an array's properties using its attributes:
  • .shape: The dimensions of the array (e.g., (rows, columns)).
  • .size: The total number of elements.
  • .dtype: The data type of the elements (e.g., int64, float64), which impacts memory and performance.

In our next lesson, we will build directly on this foundation. You'll learn how to manipulate these arrays by accessing, changing, and selecting data through indexing, slicing, and reshaping.