NumPy Operations

Python package NumPy stands for "Numerical Python." The logical computation package includes an efficient N-D array object and provides facilities to link C, C++, and other programming languages. Additionally, it helps with arbitrary number capacity, linear-based math, and other subjects. NumPy displays can be used as a powerful multi-dimensional container for general data. Python Array: Rows and columns make up the robust N-dimensional object known as a Numpy array. We may access its elements and initialize NumPy arrays using a nested Python list. On a structural plane, a Numpy array consists of a mixture of:

The Data reference displays the memory location of the Numpy array's initial byte.
The name Data type or the dtype argument describes the Python types of elements stored within the particular array.
The shape denotes the number of rows and columns the array has.
The strides specify how many bytes in the system's memory should be bypassed before moving on to the next array element.

Numpy Basics

Array of Ones

Creates a NumPy array according to the parameters given, with all elements being 1.

Code

# Python program to create a numpy array of ones
array = np.ones([2,3])
print(array)

Output

[[1. 1. 1.]
 [1. 1. 1.]]

Array of Zeros

This function returns a NumPy array with all entries set to 0 having dimensions as specified.

Code

# Python program to create a numpy array of zeroes
array = np.zeros([2,3])
print(array)

Output

[[0. 0. 0.]
 [0. 0. 0.]]

These functions are simple, and they can be used to create sample arrays which are often needed for various computational purposes.

Eye

Let's now examine how the eye method works. A 2-D array containing ones on its diagonal and zeros everywhere else is this function's output.

Code

# Python program to create a numpy array having ones on diagonal and zeroes elsewhere
array = np.eye(4)
print(array)# Python program to create a numpy array of ones
array = np.ones([2,3])
print(array)

Output

[[1. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 0.]
 [0. 0. 0. 1.]]

Similarly, the diag() method builds a 2D array with all other members set to zero, and the items supplied to function as arguments are set to the diagonal elements.

Code

import numpy as np 
y = np.array([78,56,89])
np.diag(y)

Output

array([[78,  0,  0],
       [ 0, 56,  0],
       [ 0,  0, 89]])

Vstack() and Hstack()

We can use the vstack() function to vertically stack two arrays and hstack() to stack two or more arrays horizontally. Let's practice with several instances.

Code

# Python program to stack two arrays

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

# Vertical stacking
array = np.vstack((array1, array2))
print("Vertically stacked: \n", array)

# Horizontal stacking
array = np.hstack((array1, array2))
print("Horizontally stacked: \n", array)

Output

Vertically stacked: 
 [[2 3 4 5]
 [4 3 5 3]
 [6 3 5 2]
 [8 2 5 8]]
Horizontally stacked: 
 [[2 3 4 5 6 3 5 2]
 [4 3 5 3 8 2 5 8]]

Operations on Numpy Array

Arithmetic Operations

Code

# Python program to perform arithmetic operations on the Numpy arrays

import numpy as np

# Initializing our array
array1 = np.arange(9, dtype = np.float_).reshape(3, 3)
print('First Array:')
print(array1)
 
print('Second array:')
array2 = np.arange(11,20, dtype = np.float_).reshape(3, 3)
print(array2)
 
print('\nAdding two arrays:')
print(np.add(array1, array2))
 
print('\nSubtracting two arrays:')
print(np.subtract(array1, array2))
 
print('\nMultiplying two arrays:')
print(np.multiply(array1, array2))
 
print('\nDividing two arrays:')
print(np.divide(array1, array2))

Output

First Array:
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]
Second array:
[[11. 12. 13.]
 [14. 15. 16.]
 [17. 18. 19.]]

Adding two arrays:
[[11. 13. 15.]
 [17. 19. 21.]
 [23. 25. 27.]]

Subtracting two arrays:
[[-11. -11. -11.]
 [-11. -11. -11.]
 [-11. -11. -11.]]

Multiplying two arrays:
[[  0.  12.  26.]
 [ 42.  60.  80.]
 [102. 126. 152.]]

Dividing two arrays:
[[0.         0.08333333 0.15384615]
 [0.21428571 0.26666667 0.3125    ]
 [0.35294118 0.38888889 0.42105263]]

numpy.reciprocal()

This method returns the argument's element-by-element inverse. When an element's absolute value is greater than 1, the outcome is always 0, and an overflow warning is shown for integer 0.

Code

# Python program to show how to perform the reciprocal operation on the NumPy arrays

# Importing the numpy library
import numpy as np

# Initializing our array
array = np.array([23, 14, 63.9, 23.5, 23.7, 13, 7])
 
print('The array is:')
print(array)
 
print('\nAfter applying the reciprocal function array is:')
print(np.reciprocal(array))

# Creating another array
array2 = np.array([24], dtype = int)

print()

print('The second array is: ')
print(array2)
 
print('After applying the reciprocal function the array is: ')
print(np.reciprocal(array2))

Output

The array is:
[23.  14.  63.9 23.5 23.7 13.   7. ]
After applying the reciprocal function array is:
[0.04347826 0.07142857 0.01564945 0.04255319 0.04219409 0.07692308
 0.14285714]

The second array is: 
[24]
After applying the reciprocal function the array is: 
[0]

numpy.power()

This function treats the original array's elements as the base in the exponents' syntax, which then raises them to the power of the adjacent elements provided in the second array argument.

Code

# Python program to show how to take powers of the numpy array
 
# Importing the numpy library
import numpy as np
 
# Initializing the array
array = np.array([3, 5, 2])
 
print('The original array is:')
print(array)
 
print('Applying the numpy power function: ')
print(np.power(array, 2))

# Initializing another array
print('The second array is:')
array_ = np.array([2, 4, 5])
print(array_)

# Giving the power as a numpy array
print('Applying the numpy power function: ')
print(np.power(array, array_))

Output

The original array is:
[3 5 2]
Applying the numpy power function: 
[ 9 25  4]
The second array is:
[2 4 5]
Applying the numpy power function: 
[  9 625  32]

numpy.mod()

This function returns the remainder of the division of the corresponding elements in the input array. The function numpy.remainder() also produces the same result.

Code

# Python program to show how to find remainders on dividing an array by an array in numpy
 
# Importing the numpy library
import numpy as np
 
# Initializing the arrays
array = np.array([5, 10, 15])
array1 = np.array([2, 4, 5])
 
print('The original array:')
print(array)
 
print('The array for diving the original array:')
print(array1)
 
print('Applying the numpy mod function:')
print(np.mod(array, array1))
 
print('Applying the numpy remainder function:')
print(np.remainder(array, array1))

Output

The original array:
[ 5 10 15]
The array for diving the original array:
[2 4 5]
Applying the numpy mod function:
[1 2 0]
Applying the numpy remainder function:
[1 2 0]

The following functions are used to perform operations on an array with complex numbers.

numpy.real() ? This function will return the real part of the given complex argument.

numpy.imag() ? This function will return the imaginary part of the complex argument.

numpy.conj() ? This function will return the complex conjugate of the given complex argument. It is obtained by swapping the sign of the imaginary part.

numpy.angle() ? This function will return the angle of the given complex argument. The function has a parameter having the keyword- degree. If set to true, the function will return the angle in degrees; otherwise, the angle is returned in radians.

Code

# Python program to show how to perform operations on the complex elements of an array in numpy
 
# Importing the numpy library
import numpy as np 

# Initializing the array
a = np.array([-6.6j, 0.9j, 14. , 1+9j]) 

print('Our complex array is:')
print(a)

print('Applying the numpy real function: ')
print(np.real(a)) 

print('Applying the numpy imag function: ')
print(np.imag(a))  

print('Applying the numpy conj function: ')
print(np.conj(a))   

print('Applying the numpy angle function: ') 
print(np.angle(a))  

print('Applying the numpy angle function again (result in degrees)') 
print(np.angle(a, deg = True))

Output

Our complex array is:
[-0.-6.6j  0.+0.9j 14.+0.j   1.+9.j ]
Applying the numpy real function: 
[-0.  0. 14.  1.]
Applying the numpy imag function: 
[-6.6  0.9  0.   9. ]
Applying the numpy conj function: 
[-0.+6.6j  0.-0.9j 14.-0.j   1.-9.j ]
Applying the numpy angle function: 
[-1.57079633  1.57079633  0.          1.46013911]
Applying the numpy angle function again (result in degrees)
[-90.          90.           0.          83.65980825]

Using Numpy Arrays with Conditional Expressions

To identify the values that meet your criterion, utilize conditionals. The outcome of a conditional operating condition is also a numpy array because "array" is also a numpy array. Our conditional check produces an array containing boolean values as its result.

Code

# Python program to perform condition operations on the array

# Initializing the array
array = np.array([20, 30, 23, 12, 53, 54, 24])

# Values greater than 30
array_30 = array >= 30
print(array_30)

# Only storing the values that are greater than 30
print(array[array_30])

# Direct method to do the above task
print(array[array >= 30])

Output

[False  True False False  True  True False]
[30 53 54]
[30 53 54]

numpy.dot()

We will begin with the cases in which both arguments are scalars or one-dimensional arrays.

Code

# Python program to find the dot product of the numpy vectors

# Directly passing the values
print(np.dot(3, 4))

# Initializing the two arrays of a single value
a = np.array([3])
b = np.array([4])
print("Dimensions of a: ", a.ndim)
print(f"The dot product of {a} and {b} is: ", np.dot(a, b))

# Initializing the two arrays of two value
a = np.array([4, -3])
b = np.array([-6, 3])
print(f"The dot product of {a} and {b} is: ", np.dot(a, b))

Output

12
Dimensions of a:  1
The dot product of [3] and [4] is:  12
The dot product of [ 4 -3] and [-6  3] is:  -33

Logical Operators

The logical operators "or" and "and" also apply to numpy arrays elementwise. For this, we can use the numpy logical_or and logical_and methods.

Code

# Python program to use logical operations on numpy arrays

# Importing the numpy library
import numpy as np

# Intializing the arrays
array = np.array([ [True, False], [True, False]])
array1 = np.array([ [False, True], [True, False]])

# Applying numpy "or" and "and" operations
print("After or operation: \n", np.logical_or(array, array1))
print("After and operation: \n", np.logical_and(array, array1))

Output

After or operation: 
 [[ True  True]
 [ True False]]
After and operation: 
 [[False False]
 [ True False]]

Implementing Operations on Arrays Having Different Shapes

Up until now, we have dealt with two distinct instances using simple operations such as "+" or "*":

an operation performed on a scalar and a numpy array
an operation used to combine two arrays having the same shape.

The next section will demonstrate that we can still apply operators even if an array has a unique shape. But only particular circumstances allow it to function.

Broadcasting

Arrays of different dimensions can be used for arithmetic operations thanks to Numpy's robust Broadcasting technique. This implies that we take a larger dimension array and a smaller dimension array, and we convert or extend the smaller dimension array to the larger dimension array multiple times to carry out an operation. To put this in another way, the smaller array can occasionally be "broadcasted" so that it takes on the same dimension as the larger array.

In our Python software, we can avoid loops with the help of broadcasting. In the C-based Numpy implementations, the iteration happens implicitly. Additionally, we refrain from making duplicates of our data.

A straightforward example is used to illustrate the broadcasting operational principle.

Code

# Python program to show how to apply operations on two numpy arrays of different shapes

# Importing the numpy library
import numpy as np

# Initializing two arrays of different lengths
arr1 = np.array([ [3, 2, 4], [1, 3, 2], [5, 3, 3] ])
arr2 = np.array([2, 2, 2])

# Original arrays
print("arr1: \n", arr1)
print("arr2: \n", arr2)

# Multiplieng the arrays
print("Multiplication using broadcasting: ")
print(arr1 * arr2)

# Adding the arrays
print("Addition using broadcasting: ")
print(arr1 + arr2)

Output

arr1: 
 [[3 2 4]
 [1 3 2]
 [5 3 3]]
arr2: 
 [2 2 2]
Multiplication using broadcasting: 
[[ 6  4  8]
 [ 2  6  4]
 [10  6  6]]
Addition using broadcasting: 
[[5 4 6]
 [3 5 4]
 [7 5 5]]

Distance Matrix

A distance matrix in geometry is a matrix or a two-dimensional array that stores the distances between the members of a set, pairwise taken, in mathematics, computer science, and particularly in graph theory. If the set has n elements, this two-dimensional array's size is n x n.

A distance matrix connecting the coordinates, in our case, the alphabet, to a hypothetical point:

Code

# Python program to find the distance matrix using numpy functions

# Importing numpy
import numpy as np
# Initializing the arrays
coord = ["A", "B", "C", "D", "E", 
          "F", "G", "H", "I", "J", 
          "K", "L", "M", "N", "O",
          "P", "Q", "R", "S", "T", 
          "U", "V", "W", "X", "Y", "Z"]

distance_from_coord = [12, 14, 13, 18, 18, 
                  16, 69, 12, 23, 24, 
                  10, 45, 35, 27, 15, 
                  33, 34, 37, 28, 22, 
                  47, 18, 19, 17, 21, 14]

distances =  np.array(distance_from_coord[:12])
print(distances)
print(np.abs(distances - distances[:, np.newaxis]))

Output

[12 14 13 18 18 16 69 12 23 24 10 45]
[[ 0  2  1  6  6  4 57  0 11 12  2 33]
 [ 2  0  1  4  4  2 55  2  9 10  4 31]
 [ 1  1  0  5  5  3 56  1 10 11  3 32]
 [ 6  4  5  0  0  2 51  6  5  6  8 27]
 [ 6  4  5  0  0  2 51  6  5  6  8 27]
 [ 4  2  3  2  2  0 53  4  7  8  6 29]
 [57 55 56 51 51 53  0 57 46 45 59 24]
 [ 0  2  1  6  6  4 57  0 11 12  2 33]
 [11  9 10  5  5  7 46 11  0  1 13 22]
 [12 10 11  6  6  8 45 12  1  0 14 21]
 [ 2  4  3  8  8  6 59  2 13 14  0 35]
 [33 31 32 27 27 29 24 33 22 21 35  0]]

Next TopicSklearn Ensemble

← prev next →