Indexing, Slicing, and Iterating
One-dimensional arrays can be indexed, sliced and iterated over, much like lists and other Python sequences.
Multidimensional arrays can have one index per axis. These indices are given in a tuple separated by commas:
Program Example: Indexing in NumPy Arrays
print("Program Name: numpy_indexing_in_arrays.py \n")
# Indexing in NumPy arrays
import numpy as np
def arr(i, j):
return(i + j**2)
#Call function arr in fromfunc()procedure.
print("Create an array named 'myarray' of size 5x4. \n")
myarray = np.fromfunction(arr, (5, 4), dtype = int)
print("The array created by formfuncton arr is: ")
print(myarray)
print()
# Let us print by Indexing
# print the last row
print("The last row of array 'myarray' is:\n ",myarray[-1])
#
print()
# print the first row
print("The first row of array 'myarray' is: \n ", myarray[0, ])
print()
# Print the first column
print("The first column of array 'myarray' is:\n ",myarray[ : , 0])
print()
# Print the last column
print("The last column of array 'myarray' is:\n ",myarray[ : , 3])
print()
# print rows[1, 2]
print("The rows 1 and 2 of array 'myarray are: \n ", myarray[1:3, : ])
#
print()
# print columns[1, 2]
print("The columns 1 and 2 of array 'myarray' are : \n ", myarray[:, 1:3 ])
print()
# using negative index
# Print the last column using negative index
print("The last column of array 'myarray' using negative index is:\n ",myarray[ : , -1])
print()
# print the element 3rd row, 2nd column
print("Elements last row and column (0,1) of array 'myarray' are: ",myarray[-1 , 0:2])
The following is the program’s output.
Program Name: numpy_indexing_in_arrays.py
Create an array named ‘myarray’ of size 5×4.
The array created by formfuncton arr is:
[[ 0 1 4 9]
[ 1 2 5 10]
[ 2 3 6 11]
[ 3 4 7 12]
[ 4 5 8 13]]
The last row of array ‘myarray’ is:
[ 4 5 8 13]
The first row of array ‘myarray’ is:
[0 1 4 9]
The first column of array ‘myarray’ is:
[0 1 2 3 4]
The last column of array ‘myarray’ is:
[ 9 10 11 12 13]
The rows 1 and 2 of array ‘myarray are:
[[ 1 2 5 10]
[ 2 3 6 11]]
The columns 1 and 2 of array ‘myarray’ are :
[[1 4]
[2 5]
[3 6]
[4 7]
[5 8]]
The last column of array ‘myarray’ using negative index is:
[ 9 10 11 12 13]
Elements last row and column (0,1) of array ‘myarray’ are: [4 5]
Array Shape
The NumPy shape function is used to determine the dimensions of an array. An array’s shape is given by the number of elements in each axis.
For example, a 2D array with “m” rows, and “n” columns has shape (m, n).
The shape function returns a tuple that indicates the number of elements along each axis of the array.
Program Example: numpy.shape()
The shape of an array can be changed with various commands. Note that the following three commands all return a modified array, but do not change the original array:
print("Program Name: shape.py \n")
import numpy as np
# Create a 2-D array named 'a'.
a = np.array([[2, 3, 4, 5, 6] , [5, 6, 7, 8, 9]])
# Find the shape of the array 'a'.
x = a.shape # Shape of the array
print("The shape of the array 'a' is: \n", x)
The following is the program’s output.
Program Name: shape.py
The shape of the array ‘a’ is:
(2, 5)
For more details, click the following link:
https://numpy.org/doc/stable/reference/routines.array-manipulation.html
Reshape function numpy.reshape()
The NumPy reshape() function changes the shape of an array without altering its data. Note that the total of elements in the new shape remain the same as in the original array.
Features:
- Change Shape: Modify the dimensions of an array.
- Data Preservation: The data within the array remains unchanged.
- Element Count Consistency: The total number of elements must be the same in both the original and new shapes.
The Syntax of the reshape() function is:
numpy.reshape(a, /, shape, order=’C’, *, copy=None)
| Parameter | Description | Notes | Returns |
|---|---|---|---|
| a | Array to be shaped | reshaped_array : ndarray | |
| shape | New shape specified in int or tuple of ints | # of elements in the new array must be same as in the original array | |
| order | Optional | ||
| copy | Optional |
In the following sections, the name of the array is assumed to be ‘a’.
The program below uses the reshape() function to change the shape of an array without altering the data.
Program Example: reshape() Function
# Program Name: reshape.py
import numpy as np
# Create an 2-D array named 'a'.
a = np.array([[2, 3, 4, 5, 6, 11] , [5, 6, 7, 8, 9, 10]])
print("2-D array 'a' is: \n",a)
print()
x = a.shape # Shape of the array
print("The shape of the array 'a' is: \n", x)
print()
print("Now use the reshape() function to shange the shape of array to 4x3. \n")
# Change the shape to (4, 3) and name the reshaped array 'y'.
y = a.reshape(4, 3)
print("The reshaped array is: \n", y)
The following is the program’s output.
2-D array ‘a’ is:
[[ 2 3 4 5 6 11]
[ 5 6 7 8 9 10]]
The shape of the array ‘a’ is:
(2, 6)
Now use the reshape() function to shange the shape of array to 4×3.
The reshaped array 4×3 is:
[[ 2 3 4]
[ 5 6 11]
[ 5 6 7]
[ 8 9 10]]
numpy.ravel() Function
NumPy’s ravel function is used to flatten a multi-dimensional array into a one-dimensional array. The function is useful in memory usage efficiency.
Syntax:
numpy.ravel(a, order=’C’)
| Parameter | Description | Notes | Returns |
|---|---|---|---|
| a | Array to be flattened | The elements in a are read in the order specified by order, and packed as a 1-D array | Contiguous 1-D array of the same subtype as a |
| order | Optional | This specifies the order in which the array elements are read. |
The program below flattens a two-dimensional array.
Program Example: ravel() Function
print("Program Name:ravel.py \n")
import numpy as np
print("Create a 2-D array named 'a'.")
a = np.array([[2, 3, 4, 9] , [5, 6, 7, 10]])
print("array 'a' is: \n", a)
# Flatten the array using ravel() command and call it array 'b'.
b = a.ravel()
print("The flattened array 'b' is: \n", b)
The following is ravel.py program’s output.
Program Name:ravel.py
Create a 2-D array named ‘a’.
array ‘a’ is:
[[ 2 3 4 9]
[ 5 6 7 10]]
The flattened array ‘b’ is:
[ 2 3 4 9 5 6 7 10]
Transpose Function numpy.T()
The NumPy transpose() function is used to change the orientation of an array by reversing its axes, effectively switching rows with columns in a 2D array.
For arrays with more than two dimensions, you can specify the order of axes to transpose
This function is used in data manipulation and linear algebra.
For more details, click on the link.
https://numpy.org/doc/stable/reference/generated/numpy.transpose.html
Syntax: numpy.transpose(a, axes=None)
| Parameter | Description | Notes | Returns |
|---|---|---|---|
| a | Input array to be transposed. | The elements in a are read in the order specified by order, and packed as a 1-D array | Returns an array with axes transposed. |
| Axes | Optional tuple or a list of ints | Specifies the order of the axes. If not provided, the default behavior reverses the dimensions. |
The program example switches the rows and columns of 2×4 2D array.
Program Example Transpose Function numpy.T()
#array transpose command
import numpy as np
a = np.array([[2, 3, 4, 9] , [5, 6, 7, 10]])
print( "The original array is: \n", a)
x = a.shape
print("The shape of the original array is : \n", x)
print()
# Transpose the array using a.T command
b = a.T.shape
print("The shape of the transposed array is: \n", b)
The following is the program’s output.
The original array is:
[[ 2 3 4 9]
[ 5 6 7 10]]
The shape of the original array is :
(2, 4)
The shape of the transposed array is:
(4, 2)
resize() Method
The NumPy resize() function creates a new array with a specified shape and size.
The reshape function returns its argument with a modified shape, whereas the ndarray.resize method modifies the array itself. See the program below.
Syntax:
Numpy.resize(a, newshape))
| Parameter | Description | Returns |
|---|---|---|
| a: is the array to be resized | The new array is formed from the data in the old array. | Reshaped array: ndarray |
| newshape: shape of the resized array int or tuple (int) |
For more exploration, click the link below.
https://numpy.org/doc/stable/reference/generated/numpy.resize.html
The following is the program example of resize() function. The function changes a (2,6) 2-D array to (6,2) array. Note that the original array itself has been modified, as opposed to reshape() function that does not change the original array.
Program Example: numpy.resize() Function
print("Program name: resize-function.py\n")
#array resize() function
import numpy as np
print("Create a 2x6 2-D array named 'a'. \n")
a = np.array([[2, 3, 4, 9, 12, 14] , [5, 6, 7, 10, 25, 18]])
print( "The original array is: \n", a)
print()
print("Print the shape of array 'a' \n")
x = a.shape
print("The shape of the original array is : \n", x)
print()
print("Resize the array 'a' using the resize() method to size (6, 2). \n")
a.resize((6, 2))
print("The resized array is: \n", a)
print()
# Note that the resize() function modified to original array 'a' itself.
print("The resized array shape is \n ",a.shape)
The following is resize() function program’s output.
Program name: resize-function.py
Create a 2×6 2-D array named ‘a’.
The original array is:
[[ 2 3 4 9 12 14]
[ 5 6 7 10 25 18]]
Print the shape of array ‘a’
The shape of the original array is :
(2, 6)
Resize the array ‘a’ using the resize() method to size (6, 2).
The resized array is:
[[ 2 3]
[ 4 9]
[12 14]
[ 5 6]
[ 7 10]
[25 18]]
The resized array shape is
(6, 2)
Stacking Together Different Arrays
NumPy allows you to stack several arrays together vertically or horizontally.
Vertical Stack numpy.vstack()
Numpy.vstack() function stacks arrays in sequence vertically (row wise).
The numpy.vstack() function is used to stack arrays vertically, meaning it combines them on top of each other. It requires that the arrays have the same number of columns to work properly.
Syntax:
numpy.vstack(tup, *, dtype=None, casting=’same_kind’)
| Parameter | Description | Notes | Returns |
|---|---|---|---|
| tup: sequence of ndarrays | A tuple of arrays to be stacked vertically. | All arrays have the same number of columns before stacking. | Output shape: The resulting array will have a number of rows equal to the sum of the rows of the input arrays and the same number of columns as the input arrays. |
| dtype | str or dtype | Optional | |
| casting | Optional |
For more details, click the link below:
https://numpy.org/doc/stable/reference/generated/numpy.vstack.html
The following program is an example of stacking two 2D arrays vertically.
Program Example: numpy.vstack() Vertical Stack
print("Program name: vstack.py \n")
import numpy as np
print("Create two arrays 'arr1' and 'arr2' to be vertically tacked. \n")
arr1 = np.array([[2, 3,4], [5, 6, 7]])
arr2 = np.array([[8, 9, 10], [12, 13, 14]])
print( "The array arr1 is: \n", arr1)
print()
# Create second array to be stacked.
print( "The arr2 is: \n", arr2)
print()
vstack_array = np.vstack((arr1, arr2))
print("Stack the arrays 'arr1' and 'arr2' vertically. \n")
print("Vetical stacked array is: \n", vstack_array)
The following is vtack.py program’s output.
Program name: vstack.py
Create two arrays ‘arr1’ and ‘arr2’ to be vertically tacked.
The array arr1 is:
[[2 3 4]
[5 6 7]]
The arr2 is:
[[ 8 9 10]
[12 13 14]]
Stack the arrays ‘arr1’ and ‘arr2’ vertically.
Vetical stacked array is:
[[ 2 3 4]
[ 5 6 7]
[ 8 9 10]
[12 13 14]]
Horizontal Stack: numpy.hstack() Function
The numpy.hstack() function is used to horizontally stack arrays in NumPy, meaning it combines them side by side along the second axis (columns). This function requires that the arrays have the same number of rows to be concatenated successfully.
Syntax:
numpy.hstack(tup, *, dtype=None, casting=’same_kind’)
| Parameter | Description | Notes | Returns |
|---|---|---|---|
| tup : sequence of ndarrays | tup: A tuple or list of arrays to be stacked. All arrays must have the same shape except along the axis being concatenated. | The arrays must have the same shape along all but the second axis, except 1-D arrays which can be any length. | Output: hatacked array |
| dtype : str or dtype | Optional | ||
| casting | Optional |
The following program is an example of stacking two 2D arrays horizontally.
Program Example: Horizontal Stack numpy.hstack()
print("Program Name: hstack.py \n")
import numpy as np
print("Create two 2-D arrays to be stacked. \n")
arr1 = np.array([[2, 3,4], [5, 6, 7]])
arr2 = np.array([[8, 9, 10], [12, 13, 14]])
print("Print array 'arr1'.")
print( "The arr1 is: \n", arr1)
print()
print("Print array 'arr2'.")
print( "The array arr2 is: \n", arr2)
print()
hstack_array = np.hstack((arr1, arr2))
print(" Horizontal stacked array is: \n", hstack_array)
The following is the program’s output.
Program Name: hstack.py
Create two 2-D arrays to be stacked.
Print array ‘arr1’.
The arr1 is:
[[2 3 4]
[5 6 7]]
Print array ‘arr2’.
The array arr2 is:
[[ 8 9 10]
[12 13 14]]
Horizontal stacked array is:
[[ 2 3 4 8 9 10]
[ 5 6 7 12 13 14]]
