You can follow github.
Numpy For Machine Learning & Deep Learning
Numpy
Numpy is a python library used to work with arrays and stands for Numarical python. It works on linear algebra, fourier transform, and matrices domain.
Numpy is faster than list because numpy provides array object.
Numpy Functions:
Note: To use numpy always import it.
import numpy as np # Here, numpy is imported as np
1. zeros(): It creates a array with zeros. Example:
array_zeros = np.zeros((3,3))
print("Array of Zeros: \n", array_zeros)
Output
Array of Zeros:
[[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]
2. ones(): It creates a array with ones. Example:
array_ones = np.ones((2,2))
print("Array of ones: \n",array_ones)
Output
Array of ones:
[[1. 1.]
[1. 1.]]
3. full(): It creates a array with all elements as 7. Example:
array_full = np.full((2,2),7)
print("Array with all elements as 7 : \n",array_full)
Output
Array with all elements as 7 :
[[7 7]
[7 7]]
4. range(): It creates a array between 0 to 20. Example:
array_range = np.arange(20)
print("Array with range of numbers : ",array_range)
Output
Array with range of numbers :
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]
5. random():
Example:
import numpy as np
# Create array
random_array = np.random.rand(3,3) # Random values in 3 X 3
normal_array = np.random.randn(3,3) # Random values with a normal distribution
print("Randmon Array : \n", random_array)
print("\n")
print("Normal Array : \n", normal_array)
Output
Randmon Array :
[[0.14635308 0.23362121 0.28310351]
[0.23209788 0.67298124 0.84145588]
[0.6829577 0.45439367 0.05747398]]
Normal Array :
[[-0.57461744 -0.09078458 -0.50067585]
[ 0.86439072 -1.44615505 0.25666949]
[ 0.01952512 -1.70556208 -0.80816368]]
6. transpose():
Example:
import numpy as np
# Create 2D array
original_array = np.array([
[1,2],
[3,4]
])
# Transpose the array
transposed_array = np.transpose(original_array)
print("Original Array: \n", original_array)
print("Transposed Array: \n", transposed_array)
Output
Original Array:
[[1 2]
[3 4]]
Transposed Array:
[[1 3]
[2 4]]
7. reshape():
Example:
import numpy as np
# Create array
original_array = np.array(
[1,4,6,7,8,9]
)
# Reshaping to different dimensions
reshaped_array = original_array.reshape((2,3))
print("Original Array : \n", original_array)
print("\n")
print("Reshaping Array : \n", reshaped_array)
Output
Original Array :
[1 4 6 7 8 9]
Reshaping Array :
[[1 4 6]
[7 8 9]]
8. concatenate():
Example:
import numpy as np
# Create an array
array1 = np.array([1,2,3])
array2 = np.array([4,5,6])
# Concatenating arrays
concatenating_array = np.concatenate((array1, array2))
print("Concatenate Array : ", concatenating_array)
Output
Concatenate Array : [1 2 3 4 5 6]
9. array_split():
Example:
import numpy as np
# create an array
array = np.array(
[1,2,34,4,5,6]
)
# Spliting the array into three parts
split_arrays = np.array_split(array,3)
print("Original Array : ", array)
print("Spiting Array : ", split_arrays)
Output
Original Array : [ 1 2 34 4 5 6]
Spiting Array : [array([1, 2]), array([34, 4]), array([5, 6])]
10. linspace():
Example:
import numpy as np
# Generating a linear space array with evenly spaced values
linear_space = np.linspace(0,10,5)
print("Linear Space : ", linear_space)
Output
Linear Space : [ 0. 2.5 5. 7.5 10. ]
11. meshgrid():
Example:
import numpy as np
# Create arrays
x = np.array([1,2,3])
y = np.array([4,5,6])
# Create a meshgrid
x,y = np.meshgrid(x,y)
print("Meshgrid X : \n",x)
print("\n")
print("Meshgrid Y : \n",y)
Output
Meshgrid X :
[[1 2 3]
[1 2 3]
[1 2 3]]
Meshgrid Y :
[[4 4 4]
[5 5 5]
[6 6 6]]
12. clip():
Example:
import numpy as np
# Create a array
array = np.array([1,2,4,5])
# Clipping values to be between 2 and 4
clipped_array = np.clip(array, 2,4)
print("Original Array",array)
print("Clipped Array",clipped_array)
Output
Original Array [1 2 4 5]
Clipped Array [2 2 4 4]
13. flatten():
Example:
import numpy as np
# Create a 2D array
array_2d = np.array(
[
[1,2,3],
[4,5,6],
[7,8,9]
]
)
# Flattening the array
flattened_array = array_2d.flatten()
print("Flattened Array : ",flattened_array)
Output
Flattened Array : [1 2 3 4 5 6 7 8 9]
Arithmetic Operations
1. add(): It adds minimum two arrays. Both array size should be same.
2. subtract(): It will minus from one array to another array & Both array size should be same.
3. multiply(): It multiplys between minimum two arrays. Both array size should be same.
4. divide(): It divides an array with another array & Both array size should be same.
Examples:
import numpy as np
# Create arrays
array1 = np.array([10,20,30])
array2 = np.array([40,50,60])
# Arithmetic Operations
added = np.add(array1, array2)
subtracted = np.subtract(array1 , array2)
multiplied = np.multiply(array1, array2)
divided = np.divide(array1, array2)
print("Added: ", added)
print("Subtracted :", subtracted)
print("Multiplied: ", multiplied)
print("Divided: ", divided)
Output
Added: [50 70 90]
Subtracted : [-30 -30 -30]
Multiplied: [ 400 1000 1800]
Divided: [0.25 0.4 0.5 ]
5. power(): A power is a number multiplied by itself a certain number of times, represented by an exponent. For example:
10^2 means 10 multiplied by itself, which is (10 X 10 = 100).
6. sqrt(): A square root of a number is a value that, when multiplied by itself, gives the original number. It is represented by the square root symbol (√).
For example:
- √121 = 11
In this case, 11 × 11 = 121, so the square root of 121 is 11.
Properties of Square Roots
- The square root of a positive number has both a positive and a negative solution (e.g., √25 = ±5), but typically, the positive root is used.
- The square root of 0 is 0.
- Negative numbers do not have real square roots (they result in imaginary numbers).
Examples :
- √144 = 12
- √64 = 8
- √49 = 7
import numpy as np
# Create array
array = np.array([2,6,4,3,7])
# Power & Square Root
squared = np.power(array, 2)
sqrt = np.sqrt(array)
print("Squared Array :", squared)
print("Square root of array :", sqrt)
Output
Squared Array :[ 4 36 16 9 49]
Square root of array : [1.41421356 2.44948974 2. 1.73205081 2.64575131]
Trigometric Functions
1. sin():
2. cos():
3. tan():
Example:
import numpy as np
# Create array
angles = np.array([0, np.pi/2, np.pi])
# Trigometric functions
sin_array = np.sin(angles)
cos_array = np.cos(angles)
tan_arraY = np.tan(angles)
print("Sins of angles: ", sin_array)
print("Cos of angles : ", angles)
print("Tan of angles : ", angles)
Output
Sins of angles: [0.0000000e+00 1.0000000e+00 1.2246468e-16]
Cos of angles : [0. 1.57079633 3.14159265]
Tan of angles : [0. 1.57079633 3.14159265]
Exponential & Logarithm Function
1. exp():
2. log():
Example:
import numpy as np
# Create an array
array = np.array([10,20,30])
# Exponential & Logarithm functions
exp_array = np.exp(array)
log_array = np.log(array)
print("Exponential of Array: ",exp_array)
print("Logarithm of Array: ",log_array)
Output
Exponential of Array: [2.20264658e+04 4.85165195e+08 1.06864746e+13]
Logarithm of Array: [2.30258509 2.99573227 3.40119738]
Statistical Functions
1. mean():
2. median():
3. std():
4. var():
import numpy as np
# Create array
array = np.array(
[1,2,3,4,5]
)
# Calculating statistical functions
mean = np.mean(array)
median = np.median(array)
std_dev = np.std(array)
variance = np.var(array)
print("Mean : ", mean)
print("Median : ", median)
print("Standard deviation : ", std_dev)
print("Variance : ", variance)
Output
Mean : 3.0
Median : 3.0
Standard deviation : 1.4142135623730951
Variance : 2.0
Unique Elements and Their Counts
1. unique(): It finds the unique elements from array. If pass the parameterretuen_counts = True, it will show the number of unique elements from an array.
Example:
import numpy as np
# Create an array
array = np.array(
[14,1,54,5,125,214,1,2,43,4,2,2,41,14,54,214,1]
)
# Finding Unique Element and their counts
unique_element , counts= np.unique(array, return_counts=True)
print("Unique Elements : ", unique_element)
print("Counts of Unique Elements: ", counts)
Output
Unique Elements : [ 1 2 4 5 14 41 43 54 125 214]
Counts of Unique Elements: [3 3 1 1 2 1 1 2 1 2]
Cumulative Sum and Product
1. cumsum():
2. cumprod():
Example:
import numpy as np
# Create a array
array = np.array([1,2,4,5])
# Calculating cumulative sum and product
cumulative_sum = np.cumsum(array)
cumulative_product = np.cumsum(array)
print("cumulative sum : ", cumulative_sum)
print("cumulative product : ", cumulative_product)
Output
cumulative sum : [ 1 3 7 12]
cumulative product : [ 1 3 7 12]
Broadcasting
Adding a scaler to an array.
Example:
import numpy as np
# create array
array = np.array(
[1,2,3]
)
# Braodcasting: Adding a scaler to an array
result = array + 10
print("Original Array: ", array)
print("Array after broadcasting : ", result)
Output
Original Array: [1 2 3]
Array after broadcasting : [11 12 13]
Sorting Array sort()
1. sort(): It sorts the array by default ascending order.
import numpy as np
# Create array
array = np.array(
[2,4,5,3,10,7,8]
)
# Sort the array
sorted_array = np.sort(array,)
print("Sorted Arrays: ", sorted_array)
Output
Sorted Arrays: [ 2 3 4 5 7 8 10]
Array Indexing & Slicing: [row:column]
Basic Indexing and Slicing
import numpy as np
# Create a array
array = np.array([1,2,4,5])
# Aceesing element by index
first_element = array[0]
# Aceesing element from the end uing negative inidices
last_element = array[-1]
second_last_element = array[-2]
# Slicing the array
slice_array = array[1:4]
# Selecting Specific indices
selected_elements = array[[1,3]]
# Slicing with a step
step_slice = array[::2] # Every Second Element
#Modifying values specific indices
array[[1,3]] = [100, 200]
# Reversing the array using slicing
reversed_array = array[::-1]
print("First Element: ", first_element)
print("Last Element: ", last_element)
print("Second Last Element: ", second_last_element)
print("Sliced Element: ", slice_array)
print("Selected Elements :", selected_elements)
print("Sliced Array with Step 2 :", step_slice)
print("Modified Array : ",array)
print("Reversed Array: ", reversed_array)
Output
First Element: 1
Last Element: 5
Second Last Element: 4
Sliced Element: [2 4 5]
Selected Elements : [2 5]
Sliced Array with Step 2 : [1 4]
Modified Array : [ 1 100 4 200]
Reversed Array: [5 4 2 1]
2D Array indexing & Slicing
import numpy as np
# Create a 2D array
array_2d = np.array(
[
[1,2,3],
[4,5,6],
[7,8,9]
]
)
# Accessing individual elements
element = array_2d[1,2] # Accessing element at row 1, column 2
# Slicing Row
row_slice = array_2d[0, : ] # First row
# Slicing Column
column_slice = array_2d[:, 1] # Second Column
# Using arrays for indexing
rows = np.array([0,1,2])
cols = np.array([2,1,0])
indexed_elements = array_2d[rows, cols]
# Multi Dimensional Slicing
sub_array = array_2d[1:, 1:3]
# Selecting specific rows and columns using slices
selected_slice = array_2d[1:, :2]
# Slicing every second element in rows and columns [Advance Slicing with Step]
step_sliced_element = array_2d[::2, ::2]
print("Element at (1,2) : ", element)
print("First Row : ", row_slice)
print("Second Column: ", column_slice)
print("Indexed Elements : ", indexed_elements)
print("Sub Array (Slicing Rows & Columns) : \n", sub_array)
print("Selected Slice : \n", selected_slice)
print("Advanced sliced array with step \n", step_sliced_element)
Output
Element at (1,2) : 6
First Row : [1 2 3]
Second Column: [2 5 8]
Indexed Elements : [3 5 7]
Sub Array (Slicing Rows & Columns) :
[[5 6]
[8 9]]
Selected Slice :
[[4 5]
[7 8]]
Advanced sliced array with step
[[1 3]
[7 9]]
3D Array Indexing & Slicing
import numpy as np
# Create a 3D array
array_3d = np.array(
[
[
[10,20], [30,40]
],
[
[50,60], [70,80]
]
]
)
# Accessing elements in a 3D Array
element = array_3d[1,0,1] # Accessing element at [1, 0 , 1]
# Slicing in 3D
slice_3D = array_3d[:, 0, : ] # First row
print("Element at (1,0,1): ", element)
print("\n")
print("Sliced 3D Array : \n", slice_3D)
Output
Element at (1,0,1): 60
Sliced 3D Array :
[[10 20]
[50 60]]
Multi Dimensional Array indexing with mixed types
import numpy as np
# Create 3D Array
array_3D = np.array([
[[1,2], [3,4]], [[5,6], [7,8]], [[9,10], [11,12]]
]
)
# Mixing slicing with direct indexing
mixed_index = array_3D[1:, 0, 1]
print("Mixed type indexing result: ", mixed_index)
Output
Mixed type indexing result: [ 6 10]
Boolean Indexing
import numpy as np
# Create a array
array = np.array(
[10,20,30,40,60,80]
)
# Boolean Indexing
greater_than_20 = array[array > 20]
# Boolean Indexing
even_numbers = array[array %2==0]
print("Original : ", array)
print("Elements greater than 20 : ",greater_than_20)
print("Even Numbers : ",even_numbers)
Output
Original : [10 20 30 40 60 80]
Elements greater than 20 : [30 40 60 80]
Elements greater than 20 : [10 20 30 40 60 80]
Fancy Indexing
import numpy as np
# Create a array
array = np.array([1,2,4,5])
# Selecting Specific indices
selected_elements = array[[1,3]]
print("Selected Elements :", selected_elements)
Output
Selected Elements : [2 5]
Combined Boolean and Fancy Indexing
import numpy as np
# Creating an array
array = np.array([10, 15, 20, 25, 30])
# Boolean condition combined with specific indices
result = array[(array > 10) & (array < 30)][[0, 2]]
print('Combined Boolean and Fancy Indexing Result:', result)
Output
Combined Boolean and Fancy Indexing Result: [15 25]
Combined Boolean , Fancy and slice indexing
import numpy as np
# Creating a 2D array
array_2d = np.array([[10, 20, 30], [40, 50, 60], [70, 80, 90]])
# Applying boolean indexing first, then fancy indexing and slicing
result = array_2d[array_2d > 30].reshape(-1, 3)[:, [0, 2]]
print('Combined Indexing Result:', result)
Output
Combined Indexing Result:
[[40 60]
[70 90]]
Conditional Indexing
import numpy as np
# Create a array
array = np.array(
[1,2,3,4,5,6]
)
# Setting elements that satisfying a condition
array[array % 2 == 0] = -1 # Set even numbers to -1
print("Array after conditional indexing : ",array)
Output
Array after conditional indexing : [ 1 -1 3 -1 5 -1]
Ellipsis Indexing
import numpy as np
# Create a 3D array
array_3D = np.array(
[[
[1,2],
[3,4],
[5,6],
[7,8],
[9,10],
[11,12]
]]
)
# Using Ellipisis to seletect all elements along axes
result = array_3D[..., 1] # Selecting the second column in each 2D Slices
print("Result using Ellipsis (...): \n", result)
Output
Result using Ellipsis (...):
[[ 2 4 6 8 10 12]]
Mask Indexing np.ma
import numpy as np
# Create array
array = np.array([1,-2,3,-4,5])
# Creating a Mask for positive values
mask = array > 0
# Applyinh mask to get only positive values
positive_values = array[mask]
# Masking elements where values are negative
masked_array = np.ma.masked_where(array < 0, array)
print("Positive Values : ", positive_values)
print("Masked Array with negative values hidden: ", masked_array)
Output
Positive Values : [1 3 5]
Masked Array with negative values hidden: [1 -- 3 -- 5]
Matrix
Indexing using np.diag() np.triu() np.tril
import numpy as np
# Create a square Matrix
matrix = np.array([
[1,2,3],
[4,5,6],
[7,8,9]
])
# Extracting the main diagnal
diagnoal_elements = np.diag(matrix)
# Extracting the upper triangle (above the main diaginal)
upper_triangle = np.triu(matrix)
# Extracting the lower triangle (below the main diaginal)
lower_triangle = np.tril(matrix)
print("Diagnoal Elements: \n", diagnoal_elements)
print("Upper Triangle of the Matrix: \n", upper_triangle)
print("Lower Triangle of the Matrix: \n", lower_triangle)
Output
Diagnoal Elements: [1 5 9]
Upper Triangle of the Matrix:
[[1 2 3]
[0 5 6]
[0 0 9]]
Lower Triangle of the Matrix:
[[1 0 0]
[4 5 0]
[7 8 9]]
Indexing using np.wehere()
import numpy as np
# Create a array
array = np.array(
[10,20,30,40,60,80]
)
# Using np.where to find indices where elements are greater than 25
indices = np.where(array > 25)
# Replacing values based on condition where elements are greater than 25
result = np.where(array > 25, 0, array)
print("Indices where elements > 25 : ",indices)
print("Values where elements > 25: ",array[indices])
print("Array with Values where elements > 25 replaced with 0: ",result)
Output
Indices where elements > 25 : (array([2, 3, 4, 5]),)
Values where elements > 25: [30 40 60 80]
Array with Values where elements > 25 replaced with 0: [10 20 0 0 0 0]
Indexing using np.take()
import numpy as np
# Create a array
array = np.array(
[10,20,30,40,60,80]
)
# Using np.take to select elements at specific indices
indices = [0,2,4]
result = np.take(array, indices)
print("Selected Elements using np.take", result)
Output
Selected Elements using np.take [10 30 60]
Indexing using advanced meshgrid() **
Example:
import numpy as np
# Create arrays
x = np.array([1,2,3])
y = np.array([4,5,6])
# Create a meshgrid
x,y = np.meshgrid(x,y)
indices = np.vstack(
[x.ravel(), y.ravel()]
)
print("Indices for Meshgrid Advanced Indexing: \n", indices)
Output
Indices for Meshgrid Advanced Indexing:
[[1 2 3 1 2 3 1 2 3]
[4 4 4 5 5 5 6 6 6]]
#### Multiple condition using np.choose() **
Example:
import numpy as np
# Create an array
array = np.array([1, 2, 4, 5])
# Extend choices to include placeholder arrays for out-of-bounds indices
choices = [array * 2, array + 10, array ** 2, array * 0, array * 0, array * 0]
# Use np.choose with the modified choices array
result = np.choose(array, choices)
print("Result using np.choose:", result)
Output
Result using np.choose: [11 4 0 0]
Top comments (0)