You've learned how to select specific elements or portions of NumPy arrays using various indexing techniques. Now, let's see how to use these same powerful selection methods to change the values within an array. This is a fundamental operation for data cleaning, transformation, and manipulation in data analysis and machine learning tasks.

The core idea is simple: any method you use to select data on the left-hand side of an assignment operator (=) can be used to assign new values to the selected elements.

Assigning Values to Single Elements

Just as you use square brackets [] with indices to access an element, you can use the same syntax to assign a new value to that specific position.

For a 1D array:

import numpy as np

# Create a simple 1D array
arr1d = np.arange(10)
print("Original 1D array:", arr1d)
# Output: Original 1D array: [0 1 2 3 4 5 6 7 8 9]

# Modify the element at index 5
arr1d[5] = 99
print("Modified 1D array:", arr1d)
# Output: Modified 1D array: [ 0  1  2  3  4 99  6  7  8  9]

For a 2D array, you use the [row, column] notation:

# Create a 2D array
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("Original 2D array:\n", arr2d)
# Output:
# Original 2D array:
#  [[1 2 3]
#  [4 5 6]
#  [7 8 9]]

# Modify the element at row 1, column 2
arr2d[1, 2] = -5
print("Modified 2D array:\n", arr2d)
# Output:
# Modified 2D array:
#  [[ 1  2  3]
#  [ 4  5 -5]
#  [ 7  8  9]]

Modifying Array Slices

Slicing allows you to select a range of elements. You can assign a single value to an entire slice, or assign an array of values matching the slice's shape.

Assigning a Scalar Value to a Slice:

When you assign a single scalar value (like a number) to a slice, NumPy uses broadcasting to fill the entire selected slice with that value.

# Recreate the 1D array
arr1d = np.arange(10)
print("Original 1D array:", arr1d)
# Output: Original 1D array: [0 1 2 3 4 5 6 7 8 9]

# Assign the value 100 to elements from index 2 up to (not including) 5
arr1d[2:5] = 100
print("Modified slice (scalar):", arr1d)
# Output: Modified slice (scalar): [  0   1 100 100 100   5   6   7   8   9]

This works similarly for 2D arrays:

# Recreate the 2D array
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("Original 2D array:\n", arr2d)
# Output:
# Original 2D array:
#  [[1 2 3]
#  [4 5 6]
#  [7 8 9]]

# Assign 0 to the top-left 2x2 sub-array
arr2d[0:2, 0:2] = 0
print("Modified slice (scalar, 2D):\n", arr2d)
# Output:
# Modified slice (scalar, 2D):
#  [[0 0 3]
#  [0 0 6]
#  [7 8 9]]

Assigning an Array to a Slice:

You can also assign another array (or list) to a slice, provided the shape of the array you are assigning matches the shape of the slice you selected.

# Recreate the 1D array
arr1d = np.arange(10)
print("Original 1D array:", arr1d)
# Output: Original 1D array: [0 1 2 3 4 5 6 7 8 9]

# Assign values from a list to a slice
arr1d[5:8] = [55, 66, 77]
print("Modified slice (array):", arr1d)
# Output: Modified slice (array): [ 0  1  2  3  4 55 66 77  8  9]

# Trying to assign an array of the wrong shape will cause an error
# arr1d[5:8] = [1, 2] # This would raise a ValueError

Important Note on Slices and Views: When you modify a slice, you are typically modifying the original array directly. This is because slices often return views of the original data, not copies. Be mindful of this, as changes made through a slice view will be reflected in the original array.

arr = np.arange(5)
print("Original array:", arr) # [0 1 2 3 4]
arr_slice = arr[1:4]
print("Slice:", arr_slice)    # [1 2 3]

arr_slice[:] = 99 # Modify all elements of the slice
print("Modified slice:", arr_slice) # [99 99 99]
print("Original array after slice modification:", arr) # [ 0 99 99 99  4]

Notice how changing arr_slice also changed arr.

Modifying with Boolean Indexing

Boolean indexing is very useful for changing elements that satisfy a certain condition. You place a boolean condition inside the square brackets. All elements where the condition evaluates to True will be selected for assignment.

# Create an array with positive and negative numbers
data = np.array([-1, 5, -3, 0, 8, -2, 4])
print("Original data:", data)
# Output: Original data: [-1  5 -3  0  8 -2  4]

# Assign the value 0 to all negative numbers
data[data < 0] = 0
print("Data after replacing negatives:", data)
# Output: Data after replacing negatives: [0 5 0 0 8 0 4]

# Assign a specific value to elements meeting another condition
data[data > 5] = 500
print("Data after capping values > 5:", data)
# Output: Data after capping values > 5: [  0   5   0   0 500   0   4]

Again, broadcasting applies. When you assign a single scalar value (like 0 or 500 above), it's assigned to all elements selected by the boolean condition.

Modifying with Fancy Indexing

Fancy indexing uses arrays of integers to specify the indices of the elements you want to access or modify. This allows for selecting and changing non-contiguous elements.

# Create a 1D array
arr = np.zeros(10, dtype=int) # Array of ten zeros
print("Initial array:", arr)
# Output: Initial array: [0 0 0 0 0 0 0 0 0 0]

# Use fancy indexing to set specific elements
indices_to_change = [1, 4, 7, 8]
arr[indices_to_change] = 99
print("Array after fancy index assignment:", arr)
# Output: Array after fancy index assignment: [ 0 99  0  0 99  0  0 99 99  0]

# You can also assign a sequence of values matching the number of indices
new_values = [11, 44, 77, 88]
arr[indices_to_change] = new_values
print("Array after assigning sequence:", arr)
# Output: Array after assigning sequence: [ 0 11  0  0 44  0  0 77 88  0]

Fancy indexing can also be used with multi-dimensional arrays:

# Create a 2D array
arr2d = np.arange(12).reshape((3, 4))
print("Original 2D array:\n", arr2d)
# Output:
# Original 2D array:
#  [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

# Select specific elements using row and column index arrays
rows = np.array([0, 1, 2])
cols = np.array([1, 2, 0]) # Select elements (0,1), (1,2), (2,0)

# Assign a value to the selected elements
arr2d[rows, cols] = -1
print("Modified 2D array (fancy indexing):\n", arr2d)
# Output:
# Modified 2D array (fancy indexing):
#  [[ 0 -1  2  3]
#  [ 4  5 -1  7]
#  [-1  9 10 11]]

Unlike basic slicing, assignments via boolean or fancy indexing sometimes create copies implicitly, but the practical result is that the intended elements in the original array structure are updated. The key takeaway is that the same flexible selection mechanisms work effectively for assignment.

Being able to select subsets of your data using indexing, slicing, boolean conditions, or index arrays, and then directly modify those subsets, is a cornerstone of data manipulation in NumPy. You'll use these techniques frequently when preparing data for analysis or machine learning models.