How do you find the Index of Value in Python's NumPy Array?
NumPy is a Python library that stands for Numerical Python that is used for scientific computation. Like SciPy (Scientific Python), Scikit-learn, Pandas, and NumPy are similar. NumPy provides an array that is very powerful in performing scientific computation. NumPy array is the type of data structure provided by the NumPy library. NumPy consists of a collection of tools and techniques that are used to solve mathematical problems in data science. An array is a collection of similar data stored at contiguous memory locations.
Let’s see a code to see how an array is defined in NumPy,
Code:
import numpy as np
# Define a 1D array
my_array = np.array([[1, 2, 3, 4],
[5, 6, 7, 8]],
dtype=np.int64)
# Define a 2D array
my_2d_array = np.array([[1, 2, 3, 4],
[5, 6, 7, 8]],
dtype=np.int64)
# Define a 3D array
my_3d_array = np.array([[[1, 2, 3, 4],
[5, 6, 7, 8]],
[[1, 2, 3, 4],
[9, 10, 11, 12]]],
dtype=np.int64)
# Print the 1D array
print("Printing my_array:")
print(my_array)
# Print the 2D array
print("Printing my_2d_array:")
print(my_2d_array)
# Print the 3D array
print("Printing my_3d_array:")
print(my_3d_array)
Output:
Printing my_array:
[[1 2 3 4]
[5 6 7 8]]
Printing my_2d_array:
[[1 2 3 4]
[5 6 7 8]]
Printing my_3d_array:
[[[ 1 2 3 4]
[ 5 6 7 8]]
[[ 1 2 3 4]
[ 9 10 11 12]]]
Explanation:
In the above code, the NumPy module is imported, and the 1-D array, 2-D array and 3-D array are defined. The array is defined using the array method provided by NumPy, and the type of data in the array is integer type, and the array is printed.
To check the data, shape of the NumPy array and data type of the array, NumPy provides the data, shape and dtype attributes to check these.
To define a NumPy array, the np.array() function is used. A list is passed to the function to define the array.
Code:
import numpy as np
# Make the array `my_array`
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Print `my_array`
print(my_array)
Output:
[[1 2 3 4] [5 6 7 8]]
Explanation:
In the above code the NumPy module is imported, and the array is defined with the help of the array method provided by NumPy.
Create an "Empty" NumPy array:
The NumPy array with ones or zeros can be initialized, but the array that gets filled by spaced values, constant or random values.
Code:
import numpy as np
# Create an array of ones
ones_array = np.ones((3, 4))
print("Ones Array:")
print(ones_array)
print()
# Create an array of zeros
zeros_array = np.zeros((2, 3, 4), dtype=np.int16)
print("Zeros Array:")
print(zeros_array)
print()
# Create an array with random values
random_array = np.random.random((2, 2))
print("Random Array:")
print(random_array)
print()
# Create an empty array
empty_array = np.empty((3, 2))
print("Empty Array:")
print(empty_array)
print()
# Create a full array
full_array = np.full((2, 2), 7)
print("Full Array:")
print(full_array)
print()
# Create an array of evenly-spaced values
arange_array = np.arange(10, 25, 5)
print("Arange Array:")
print(arange_array)
print()
# Create an array of evenly-spaced values
np.linspace(0,2,9)
Output:
Ones Array:
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
Zeros Array:
[[[0 0 0 0]
[0 0 0 0]
[0 0 0 0]]
[[0 0 0 0]
[0 0 0 0]
[0 0 0 0]]]
Random Array:
[[0.74732304 0.68488651]
[0.48437271 0.1550345 ]]
Empty Array:
[[0. 0.]
[0. 0.]
[0. 0.]]
Full Array:
[[7 7]
[7 7]]
Arange Array:
[10 15 20]
array([0. , 0.25, 0.5 , 0.75, 1. , 1.25, 1.5 , 1.75, 2. ])
Explanation:
In the above code, the NumPy module is imported, and the array of 1's is created of size 12, the number of rows is 3, and the number of columns is 4 with the help of the np.ones() method, and the ones array is printed. The zero array is made with the help of the np.zeros() function of size 12. A random array is created with the help of the random.random() function provided by the NumPy module. An empty array of size 6 is generated with a number of rows 3 and a number of columns 2. A matrix of size 4 is created with an element of size 7. An array of linspace is created with the range 0 to 2 in the of 9 elements.
The indexing in Python NumPy array is used to access the values in the 1-dimensional and multi-dimensional arrays. Indexing is a type of operation that is used to select elements or values from a NumPy array. The Index in the array starts from zero. Hence, there is a difference between the value and the Index, i.e., where the value is present in the array.
Code:
import numpy as np
# Quick examples of numpy array indexing
# Example 1: Use NumPy.array()
# To get the first value
arr = np.array([2, 4, 6, 8])
arr2 = arr[0]
# Example 2: Use NumPy.array()
# To get the third and fourth elements
arr = np.array([2, 4, 6, 8])
arr2 = arr[2] + arr[3]
# Example 3: Use array Indexing
# To get the values of two-dimensional arrays
arr = np.array([[0,3,5,7,9], [11,13,15,17,19]])
arr2 = arr[0, 2]
# Example 4: Use array Indexing
# To get the values of 2-D arrays
arr = np.array([[0,3,5,7,9], [11,13,15,17,19]])
arr2 = arr[1, 3]
# Example 5: Access values of 3-dimensional arrays using Index
arr = np.array([[[0,3,5,], [7,9,11]], [[13, 15, 17], [19, 21, 23]]])
arr2 = arr[0, 1, 2]
# Example 6: Use negative array index
arr = np.array([[0,3,5,7,9],[11,13,15,17,19]])
arr2 = arr[0, -1]
# Example 7: Access the last element of the last row
# Using negative indexing
arr = np.array([[0,3,5,7,9],[11,13,15,17,19]])
arr2 = arr[1, -1]
Output:
[2 4 6 8] 2 [2 4 6 8] 14 14 5 [[ 0 3 5 7 9] [11 13 15 17 19]] 17 [[[ 0 3 5] [ 7 9 11]] [[13 15 17] [19 21 23]]] 11 [[ 0 3 5 7 9] [11 13 15 17 19]] 9 [[ 0 3 5 7 9] [11 13 15 17 19]] 19
Explanation:
In the above, the numpy module is imported, and an array is created with the help of the np.array method that takes the parameter list of the number, and the array is printed. An element is selected at index 0 and printed. Index 2 and 3 elements are added and stored in the arr2, and the result is printed. A 2-D array is created with the help of the np.array method with the rows and columns. The element at the 0th row and the 2nd columns are selected, and the result is printed. The element in the 1st row index and the element in the 3rd column are selected, and the result is printed. A 3-D NumPy array is created with the 4 rows and the 3 columns. The element at the 0th row, 1st column, and 2nd Index is selected, and the element is printed. The numpy array elements can also be accessed from the last, as we can see from the 0th row, which is selected, and the element from the last row is selected, and the result is printed.
Get the 1-Dimensional NumPy Array Values Using Indexing:
The indexing of the NumPy's ndarrays is done with the help of the Python x[obj] standard syntax, where x is the NumPy array and the obj is the Index for the element that is to be selected. An element of the NumPy array can be accessed by inserting the index number. The indexes in the NumPy array start with 0, meaning that the first element in the numpy array starts with the Index 0, the second element has the Index 1, etc. The values are stored individually in the 1-D arrays, so the values can be accessed with the help of their indices. Because the array values have their own Index, the elements of the NumPy array can also be accessed with the help of NumPy array slicing. If the NumPy array is one-dimensional and the element is accessed with the help of indexing. Then, the value can select with the help of the index value.
Code:
# Import numpy module
import numpy as np
# Create input array
arr = np.array([2, 4, 6, 8])
print("Original array:",arr)
# Use NumPy.array()
# To get the first value
arr2 = arr[0]
print("Getting first value:",arr2)
Output:
Original array: [2 4 6 8]
Getting first value: 2
Explanation:
In the above code, the NumPy module is imported, and the array method is used to create an array. The original array is printed, the element at index 0 is selected, and the result values are printed.
Let's see another example where the two values at different indices are calculated.
Code:
# Create input array
import numpy as np
arr = np.array([2, 4, 6, 8])
print("Original array:",arr)
# Use NumPy.array()
# To get the third and fourth elements
arr2 = arr[2] + arr[3]
print("Sum of third and fourth elements:",arr2)
Output:
Original array: [2 4 6 8]
Sum of third and fourth elements: 14
Explanation:
In the above, the NumPy module is imported, and the array is created with the elements 2, 4, 6, and 8. The original array is printed, and the value at index 2 and the value at index 3 is selected, then the value is summed. The values at index 2 and 3 are 6 and 8, respectively, and the result is 14.
We can also find the Index of 2-D Array with the help of array indexing by using comma-separated integers that represent the dimension and the Index of the element. 2-D arrays are similar to tables with rows and columns, where the row represents the dimension and the Index represents the columns.
Code:
# Create 2D input array
import numpy as np
arr = np.array([[0,3,5,7,9], [11,13,15,17,19]])
# Use array Indexing
# To get the values of two-dimensional arrays
arr2 = arr[0, 2]
print("3rd value on 1st row:",arr2)
Output:
3rd value on 1st row: 5
Explanation:
In the above code, the NumPy module is imported, a NumPy 2-D array is created, and the value at Index 0,2 two is selected, which means the value is present at row 0 and column 2, which is 5.
Let’s see another example if you want to select the 4th element of the 2nd row.
Code:
# Create 2D input array
import numpy as np
arr = np.array([[0,3,5,7,9], [11,13,15,17,19]])
# Use array Indexing
# To get the values of two-dimensional arrays
arr2 = arr[1, 3]
print("3rd value on 1st row:",arr2)
Output:
3rd value on 1st row: 17
Explanation:
In the above code, the value selected in row 1 and column 3 is 17.
We can also get the value in the 3-D array with the help of array indexing. If there is a 3-D dimensional array, a value can be accessed with the help of array indexing. The value can be accessed by accessing the value at position (0,1,2). Let's see an example of accessing the value in a 3-D NumPy array.
Code:
# Create 3D input array
import numpy as np
arr = np.array([[[0,3,5,], [7,9,11]], [[13, 15, 17], [19, 21, 23]]])
# Access values of 3-dimensional arrays using Index
arr2 = arr[0, 1, 2]
print("Value at position (0, 1, 2):",arr2)
Output:
Value at position (0, 1, 2): 11
Explanation:
In the above code, the NumPy module is imported, the 3-D array is created, and the element is accessed that is at index level 0, row 1 and column 2, which is 11.
Negative indexing can also be used to access the element of the array with the help of array indexing. Let’s see a code to access the element of the 2-D array with the help of negative array indexing.
Code:
# Create 3D input array
import numpy as np
# Create 2D input array
arr = np.array([[0,3,5,7,9],[11,13,15,17,19]])
# Use negative array index
arr2 = arr[0, -1]
print('Last element from 1st dimensional:',arr2)
# Output:
# Last element from 1st dimensional: 9
# Access the last element of the last row
# Using negative indexing
arr2 = arr[1, -1]
print('Last element from 2nd dimensional:',arr2)
Output:
Last element from 1st dimensional: 9
The last element from 2nd dimensional: 19
Explanation:
In the above code, the NumPy array is imported, and a new 2-D array is created. An element is accessed with row 0 and column -1, which is the last column, and another element is accessed with row 0 and column -1, and the result is 9 and 19, respectively.
Conclusion:
In the article, we have seen how an element is accessed with the help of array indexing in NumPy since accessing the element from the array can be helpful in many ways, like adding the element of the array and multiplying the array element and can help change values in the array. Array index can be used with 1-D, 2-D and 3-D arrays.