Jupyter Guide

To get started, open the file on the right entitled "Step 1...". You'll complete each task for Step 1 in that Jupyter Notebook file. Remember, you must run the cells (ctrl/cmd + Enter) for each task before moving onto the next task in the Jupyter Notebook. Continue until you have completed all tasks in this step. Then when you are ready to move onto the next step, you'll come back and click on the file for the next step until you have completed all tasks in all steps of the lab.

Getting Started with NumPy Arrays

To review the concepts covered in this step, please refer to the Creating and Accessing Arrays module of the Accessing Arrays with NumPy course.

Understanding NumPy arrays is important because they provide a more efficient and versatile way to handle data in Python. They allow for faster computations and more advanced operations compared to standard Python lists or tuples.

In this step, we will dive into the world of NumPy arrays. Our goal is to understand how they differ from standard Python data structures and how to create them. We will use the numpy.array() function to create one-dimensional and multi-dimensional arrays from Python lists. We will also explore the dtype argument to specify the data type of the elements in the array.

Task 1.1: Importing NumPy

Before we can start working with NumPy, we need to import the library. The convention is to import NumPy with an alias, np.

import module as alias

# Import libraries
import numpy as np

Task 1.2: Creating a One-Dimensional NumPy Array

Create a 1D NumPy array from a Python list. The list should contain the numbers 1 through 5. Display the results.

# Create a 1D numpy array
arr = np.array([1, 2, 3, 4, 5])
arr

Task 1.3: Creating a Multi-Dimensional NumPy Array

Create a 2D NumPy array from a Python list. The list should contain two sublists, the first containing the numbers 1 through 3 and the second containing 4 through 6. Display the results.

list_2d = [[1],[2]]

# Create a 2D numpy array
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])
arr_2d

Task 1.4: Specifying the Data Type of a NumPy Array

Create a NumPy array with the numbers 1 through 5, but specify the data type of the elements to be float. Display the results. Notice the difference from Task 1.2: the numbers in the array should now be represented as floating point numbers as opposed to integers.

# Specify the data type
arr_float = np.array([1, 2, 3, 4, 5], dtype=float)
arr_float

Creating and Accessing NumPy Arrays

To review the concepts covered in this step, please refer to the Creating and Accessing Arrays module of the Accessing Arrays with NumPy course.

Creating and accessing NumPy arrays is important because it forms the basis for any operation we want to perform on the data. Understanding how to index and slice arrays allows us to access and manipulate specific parts of the data.

In this step, we will focus on creating and accessing NumPy arrays. We will use the numpy.arange() and numpy.linspace() functions to generate 1D arrays, and the numpy.diag() and numpy.eye() functions to generate 2D arrays. We will also learn how to index and slice arrays to access specific elements or sections of the array. Sure, here's the updated content with a more detailed hint for each task and the first task now focused on importing numpy.

Task 2.1: Importing NumPy

Import the NumPy library using the standard alias np.

import numpy as np

Task 2.2: Creating a 1D array using np.arange()

Create a 1D array of integers from 0 to 9 using the np.arange() function. Display the array.

# Assuming numpy has been imported as np
array_1d = np.arange(10)
array_1d

Task 2.3: Creating a 1D array using np.linspace()

Create a 1D array of 5 evenly spaced numbers between 0 and 1 using the np.linspace() function. Display the array.

# Assuming numpy has been imported as np
array_linspace = np.linspace(0, 1, 5)
array_linspace

Task 2.4: Creating a 2D array using np.diag()

Create a 2D array with the numbers 1, 2, 3, 4 on the diagonal using the np.diag() function. Display it.

# Assuming numpy has been imported as np
array_diag = np.diag([1, 2, 3, 4])
array_diag

Task 2.5: Creating a 2D array using np.eye()

Create a 2D array with ones on the diagonal and zeros elsewhere using the np.eye() function. Display it.

# Assuming numpy has been imported as np
array_eye = np.eye(4)
array_eye

Task 2.6: Accessing elements of a 1D array

Access the 5th element of the 1D array created using the np.arange() function in Task 2.2. Display it.

# Assuming numpy has been imported as np and array_1d is defined
fifth_element = array_1d[4]
fifth_element

Task 2.7: Slicing a 1D array

Slice the 1D array created using the np.arange() function in Task 2.2 to get the 3rd, 4th, 5th, and 6th elements. Display them.

# Assuming numpy has been imported as np and array_1d is defined
sliced_array = array_1d[2:7]
sliced_array

Task 2.8: Accessing elements of a 2D array

Given a 2D array created using the np.eye() function in Task 2.5, access the element in the second row and third column. Display it.

# Assuming numpy has been imported as np and array_eye is defined
element_2d = array_eye[1, 2]
element_2d

Advanced Array Indexing

To review the concepts covered in this step, please refer to the Advanced Array Indexing Routines module of the Accessing Arrays with NumPy course.

Advanced array indexing is important because it provides more flexibility and control over the data. It allows us to select multiple elements, reshape the array, and even filter elements based on certain conditions.

In this step, we will delve into advanced array indexing techniques. We will learn how to select multiple elements using a list of indices, perform Boolean indexing, and reshape arrays using the reshape() method. We will also learn how to flatten a multi-dimensional array into a one-dimensional array.

Task 3.1: Creating an Initial 2D Array of Numeric Data

Create a 2D array of numeric data with at least 3 rows and 3 columns. Let's call this array data_matrix. There should be at least one number greater 50 and one less than 50 in your array. Display the array.

# Create a 2D array of numeric data
data_matrix = np.array([
    [10, 20, 30],
    [40, 50, 60],
    [70, 80, 90]
])

# Display the data_matrix
data_matrix

Task 3.2: Selecting Multiple Elements Using a List of Indices

Select multiple elements from the data_matrix using a list of row and column indices. For this task, select elements at positions (0, 2), (1, 1), and (2, 0). Display the results.

# Assume data_matrix is already defined as a 2D array from the previous task
# Select elements at positions (0, 2), (1, 1), and (2, 0)
selected_elements = data_matrix[[0, 1, 2], [2, 1, 0]]

# Display the selected elements
selected_elements

Task 3.3: Performing Boolean Indexing

Perform Boolean indexing to select all elements from data_matrix that are greater than 50. Print the boolean index as well as the results of the array indexed with the boolean index.

# Assume data_matrix is already defined as a 2D array from previous tasks
# Perform Boolean indexing to select all elements greater than 50
greater_than_fifty = data_matrix[data_matrix > 50]

# Display the boolean mask
print(data_matrix>50)
	
# Display the elements greater than 50
greater_than_fifty

Task 3.4: Reshaping Arrays

Reshape the data_matrix into a 2D array with 1 row. Store the result in a variable named single_row_matrix. Display the results.

# Assume data_matrix is already defined as a 2D array from previous tasks
# Reshape the data_matrix into a 2D array with 1 row
single_row_matrix = data_matrix.reshape((1, -1))

# Display the reshaped single row matrix
single_row_matrix

Task 3.5: Flattening a Multi-dimensional Array

Flatten the data_matrix into a 1D array. Store the result in a variable named flattened_data. Display the results. Compare your result to the Task 3.4. Notice the extra dimension in the array displayed from Task 3.4.

# Assume data_matrix is already defined as a 2D array from previous tasks
# Flatten the data_matrix into a 1D array
flattened_data = data_matrix.ravel()

# Display the flattened data
flattened_data

Broadcasting in NumPy

To review the concepts covered in this step, please refer to the Broadcasting module of the Accessing Arrays with NumPy course.

Broadcasting is important because it allows us to perform operations on arrays of different shapes. This is a powerful feature that makes NumPy a versatile tool for data manipulation and computation.

In this step, we will explore broadcasting in NumPy. We will learn how NumPy compares the shapes of two arrays to determine if they are compatible for broadcasting. We will also perform computations on arrays with different shapes using NumPy's broadcasting feature.

Task 4.1: Importing NumPy

First, we need to import the NumPy library to use its functions.

import numpy as np

Task 4.2: Creating Arrays

Create two NumPy arrays of different shapes. One array should be 1-dimensional with three elements and the other should be 2-dimensional with 2 rows and 3 columns. Display the results.

array1 = np.array([1, 2, 3])
array2 = np.array([[1, 2, 3], [4, 5, 6]])
print(array1)
print(array2)

Task 4.3: Understanding Broadcasting

Perform an operation (like addition) on the two arrays you created. Observe the result and try to get a feel for how broadcasting works.

result = array1 + array2
print(result)
	
result = array1 * array2
print(result)

Task 4.4: Broadcasting with Different Shapes

Create two new arrays of different shapes that are not compatible for broadcasting. Try to perform an operation on these arrays and observe the error message.

array3 = np.array([[1, 2, 3], [4, 5, 6]])
array4 = np.array([[1, 2], [3, 4], [5, 6]])
try:
    result = array3 + array4
except ValueError as e:
    print(e)

Iterating over NumPy Arrays

To review the concepts covered in this step, please refer to the Iterating over NumPy Arrays module of the Accessing Arrays with NumPy course.

In this step, we'll focus on a crucial skill for data practicioners: iterating through NumPy arrays. It's a fundamental technique that enables efficient data access and manipulation. Let's dive right in!

Task 5.1: Importing NumPy

Before we can start working with NumPy arrays, we need to import the NumPy library. Import the NumPy library as np.

import numpy as np

Task 5.2: Creating a NumPy Array

Create a 1D NumPy array named arr with the values from 1 to 5.

arr = np.array([1, 2, 3, 4, 5])

Task 5.3: Iterating Over a 1D Array

Iterate over the arr array using a for loop and print each element.

for i in arr:
    print(i)

Task 5.4: Creating a 2D Array

Create a 2D NumPy array named arr_2d with the values from 1 to 9 reshaped into a 3x3 matrix.

arr_2d = np.arange(1,10).reshape(3, 3)

Task 5.5: Iterating Over a 2D Array (Double For Loop)

Iterate over the arr_2d array using a double for loop to print each element.

for row in arr_2d:
    for element in row:
        print(element)