arrayprogs

November 29, 2024

[1]: #---------------------------------------------------------------------------------------------
#numpy stddev

import numpy as np

# create a numpy array

marks = np.array([76, 78, 81, 66, 85])

# compute the standard deviation of marks

std_marks = np.std(marks)
print("\n the standard deviation of marks : ")
print(std_marks)

# create a 2D array
array1 = np.array([[2, 5, 9],
[3, 8, 11],
[4, 6, 7]])

# compute standard deviation along horizontal axis

result1 = np.std(array1, axis=1)
print("Standard deviation along horizontal axis:", result1)

# compute standard deviation along vertical axis

result2 = np.std(array1, axis=0)
print("Standard deviation along vertical axis:", result2)

# compute standard deviation of entire array

result3 = np.std(array1)
print("Standard deviation of entire array:", result3)

the standard deviation of marks :

6.368673331236263
Standard deviation along horizontal axis: [2.86744176 3.29983165 1.24721913]
Standard deviation along vertical axis: [0.81649658 1.24721913 1.63299316]
Standard deviation of entire array: 2.7666443551086073

1
[5]: #---------------------------------------------------------------------------------------------

#numpyrand
#rand in numpy
import numpy as np
from numpy import random

x = random.randint(100)
print("\n Random integer from 0 to 100 ")
print(x)

#Generate a random float from 0 to 1:

x = random.rand()
print("\n Random float from 0 to 1 ")
print(x)

#randomly constructing 2D array

array = random.randn(3, 2)
print("\n 3X2 Array filled with random float values : \n", array);

#The choice() method allows you to generate a random value based on an array of␣
↪values.

#The choice() method takes an array as a parameter and randomly returns one of␣
↪the values.

x = random.choice([3, 5, 7, 9])
print("\n Random integer from array elements ")
print(x)

#Generate a 2-D array that consists of the values in the array parameter (3, 5,␣
↪7, and 9)

x = random.choice([3, 5, 7, 9], size=(3, 5))

print("\n 3X5 Array filled with random integer from array elements : \n")
print(x)

#The shuffle() method takes a sequence, like a list

mylist = ["apple", "banana", "cherry", "orange"]
random.shuffle(mylist)
print("\n Shuffled list ")
print(mylist)

#permutation() Generate a random permutation of elements of following array

arr = np.array([1, 2, 3, 4, 5])
print("\n random permutation of elements ")
print(random.permutation(arr))

#Set the seed() value to 10

2
 random.seed(10)
print("\n seed() output")
print(random.rand(4))

Random integer from 0 to 100

89

Random float from 0 to 1

0.5833217369377363

3X2 Array filled with random float values :

[[-0.90561048 -0.89808938]
[ 0.45187984 -0.85947418]
[-0.53479453 1.03287114]]

Random integer from array elements

3

3X5 Array filled with random integer from array elements :

[[9 7 7 5 3]
[3 7 5 9 7]
[5 5 5 9 5]]

Shuffled list
['orange', 'apple', 'banana', 'cherry']

random permutation of elements

[4 3 5 1 2]

seed() output
[0.77132064 0.02075195 0.63364823 0.74880388]

[37]: #---------------------------------------------------------------------------------------------

#numpy percentile

import numpy as np

# create an array
array1 = np.array([1, 3, 5, 7, 9, 11, 13, 15, 17, 19])

# compute the 25th percentile of the array

result1 = np.percentile(array1, 25)
print("25th percentile:",result1)

3
 # compute the 75th percentile of the array
result2 = np.percentile(array1, 75)
print("75th percentile:",result2)

'''
Here,

25% of the values in array1 are less than or equal to 5.5.

75% of the values in array1 are less than or equal to 14.5.'''

25th percentile: 5.5

75th percentile: 14.5

[37]: '\nHere,\n\n25% of the values in array1 are less than or equal to 5.5.\n75% of
the values in array1 are less than or equal to 14.5.'

[9]: #---------------------------------------------------------------------------------------------

#numpyminmax
import numpy as np

# create an array
array1 = np.array([2,6,9,15,17,22,65,1,62])

# find the minimum value of the array

min_val = np.min(array1)

# find the maximum value of the array

max_val = np.max(array1)

# print the results

print("Minimum value:", min_val)
print("Maximum value:", max_val)

Minimum value: 1
Maximum value: 65

[11]: #---------------------------------------------------------------------------------------------

#numpymedian
import numpy as np

# create a 1D array with 5 elements

array1 = np.array([1, 2, 3, 4, 5])

# calculate the median in case of odd number of elements

median = np.median(array1)

4
print("\n Median for odd number of elements : ")
print(median)

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

# calculate the median in case of even number of elements

median = np.median(array1)
print("\n Median for even number of elements : ")
print(median)

print("\n\n **********Median of NumPy 2D Array *******")

'''
If we specify,
axis = 0, median is calculated along vertical axis
axis = 1, median is calculated along horizontal axis '''

# create a 2D array
array1 = np.array([[2, 4, 6],
[8, 10, 12],
[14, 16, 18]])

# compute median along horizontal axis

result1 = np.median(array1, axis=1)

print("Median along horizontal axis :", result1)

# compute median along vertical axis

result2 = np.median(array1, axis=0)

print("Median along vertical axis:", result2)

# compute median of entire array

result3 = np.median(array1)

print("Median of entire array:", result3)

Median for odd number of elements :

3.0

Median for even number of elements :

3.5

**********Median of NumPy 2D Array *******

Median along horizontal axis : [ 4. 10. 16.]

5
 Median along vertical axis: [ 8. 10. 12.]
Median of entire array: 10.0

[13]: #---------------------------------------------------------------------------------------------

#numpymean
import numpy as np

# create a numpy array

marks = np.array([76, 78, 81, 66, 85])

# compute the mean of marks

mean_marks = np.mean(marks)
print("\n Mean of entire array:")
print(mean_marks)

# create a 2D array
array1 = np.array([[1, 3],
[5, 7]])

# calculate the mean of the entire array

result1 = np.mean(array1)
print("Entire Array:",result1)

# calculate the mean along vertical axis (axis=0)

result2 = np.mean(array1, axis=0)
print("Along Vertical Axis:",result2)

# calculate the mean along (axis=1)

result3 = np.mean(array1, axis=1)
print("Along Horizontal Axis :",result3)

Mean of entire array:

77.2
Entire Array: 4.0
Along Vertical Axis: [3. 5.]
Along Horizontal Axis : [2. 6.]

[15]: #---------------------------------------------------------------------------------------------

#numpyarraysaveloadnpy
#Save/Load Single NumPy Array in text File

import numpy as np

array1 = np.array([[2, 4, 6],

6
 [8, 10, 12]])

# save the array to a file

np.save('file1.npy', array1)

print("\n Array Saved...")

# load the saved NumPy array

loaded_array = np.load('file1.npy')
print("\n Array Loaded...")
# display the loaded array
print(loaded_array)

Array Saved…

Array Loaded…
[[ 2 4 6]
[ 8 10 12]]

[17]: #---------------------------------------------------------------------------------------------

#numpyarraysaveloadbinary
#Save/Load Single NumPy Array in text File

import numpy as np

array1 = np.array([[2, 4, 6],

[8, 10, 12]])

# save the array to a file

np.save('file1.npy', array1)

print("\n Array Saved...")

# load the saved NumPy array

loaded_array = np.load('file1.npy')
print("\n Array Loaded...")
# display the loaded array
print(loaded_array)

Array Saved…

Array Loaded…
[[ 2 4 6]
[ 8 10 12]]

7
[19]: #---------------------------------------------------------------------------------------------

#numpyarraysaveload
#Save/Load Single NumPy Array in text File

import numpy as np

# create an array
array1 = np.array([[1, 3, 5], [2, 4, 6]])

# save the array to a text file

np.savetxt('data.txt', array1)
print("\n Array Saved...")
# load the data from the text file
loaded_data = np.loadtxt('data.txt')
print("\n Array Loaded...")
# print the loaded data
print(loaded_data)

Array Saved…

Array Loaded…
[[1. 3. 5.]
[2. 4. 6.]]

[23]: #---------------------------------------------------------------------------------------------

#arraysplitting
# Python program to demonstrate splitting in numpy

import numpy as np

#Split the array in 3 parts

arr = np.array([1, 2, 3, 4, 5, 6])

newarr = np.array_split(arr, 3)
print("\n\n Splitting the array in 3 parts ")
print(newarr)

#Split the array in 4 parts

arr = np.array([1, 2, 3, 4, 5, 6])

newarr = np.array_split(arr, 4)
print("\n\n Splitting the array in 4 parts ")
print(newarr)

8
print("\n *******************Splitting 2-D Arrays **************************")
#Split the 2-D array into three 2-D arrays.
arr = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]])
newarr = np.array_split(arr, 3)
print("\n\n Splitting the array into three 2-D arrays ")
print(newarr)

#Split the 2-D array into three 2-D arrays.

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15],␣
↪[16, 17, 18]])

newarr = np.array_split(arr, 3)
print("\n\n Splitting the array into three 2-D arrays ")
print(newarr)

#Use the hsplit() method to split the 2-D array into three 2-D arrays along␣
↪rows.

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15],␣
↪[16, 17, 18]])

newarr = np.hsplit(arr, 3)
print("\n After splitting the 2-D array into three 2-D arrays along rows")
print(newarr)

#Use the vsplit() method to split the 2-D array into three 2-D arrays along␣
↪rows.

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15],␣
↪[16, 17, 18]])

newarr = np.vsplit(arr, 3)
print("\n After splitting the 2-D array into three 2-D arrays along Columns")
print(newarr)

#Use the dsplit() method to split the 3-D array into 2 arrays along depth.
arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
newarr = np.dsplit(arr, 2)
print("\n After splitting the 2-D array into three 2-D arrays along depth")
print(newarr)
newarr = np.hsplit(arr, 2)
print("\n After splitting the 2-D array into three 2-D arrays along rows")
print(newarr)
newarr = np.vsplit(arr, 2)
print("\n After splitting the 2-D array into three 2-D arrays along Columns")
print(newarr)

Splitting the array in 3 parts

[array([1, 2]), array([3, 4]), array([5, 6])]

9
 Splitting the array in 4 parts
[array([1, 2]), array([3, 4]), array([5]), array([6])]

*******************Splitting 2-D Arrays **************************

Splitting the array into three 2-D arrays

[array([[1, 2],
[3, 4]]), array([[5, 6],
[7, 8]]), array([[ 9, 10],
[11, 12]])]

Splitting the array into three 2-D arrays

[array([[1, 2, 3],
[4, 5, 6]]), array([[ 7, 8, 9],
[10, 11, 12]]), array([[13, 14, 15],
[16, 17, 18]])]

After splitting the 2-D array into three 2-D arrays along rows
[array([[ 1],
[ 4],
[ 7],
[10],
[13],
[16]]), array([[ 2],
[ 5],
[ 8],
[11],
[14],
[17]]), array([[ 3],
[ 6],
[ 9],
[12],
[15],
[18]])]

After splitting the 2-D array into three 2-D arrays along Columns
[array([[1, 2, 3],
[4, 5, 6]]), array([[ 7, 8, 9],
[10, 11, 12]]), array([[13, 14, 15],
[16, 17, 18]])]

After splitting the 2-D array into three 2-D arrays along depth
[array([[[1],
[3]],

10
 [[5],
[7]]]), array([[[2],
[4]],

[[6],
[8]]])]

After splitting the 2-D array into three 2-D arrays along rows
[array([[[1, 2]],

[[5, 6]]]), array([[[3, 4]],

[[7, 8]]])]

After splitting the 2-D array into three 2-D arrays along Columns
[array([[[1, 2],
[3, 4]]]), array([[[5, 6],
[7, 8]]])]

[25]: #---------------------------------------------------------------------------------------------

#Arrayslicing
#Save/Load Single NumPy Array in text File

# Python program to demonstrate slicing in numpy

import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6, 7])

print("\n\n Slice elements from index 1 to index 5 ")
print(arr[1:5])

print("\n\n Slice elements from index 4 to the end of the array ")
print(arr[4:])

print("\n\n Slice elements from the beginning to index 4 (not included) ")
print(arr[:4])

print("\n\n Slice from the index 3 from the end to index 1 from the end ")
print(arr[-3:-1])

print("\n\n **Slice from the index 3 from the end to index 1 from the end ")
print(arr[-3:])

print("\n\n Slice every other element from index 1 to index 5 ")

11
print(arr[1:5:2])

print("\n\n Slice every other element from the entire array ")
print(arr[::2])

print("\n *******************Slicing 2-D Arrays **************************")

arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])

print("\n\n From the second element, slice elements from index 1 to index 4␣
↪(not included) ")

#Remember that second element has index 1.

print(arr[1, 1:4])

print("\n\n From both elements, return index 2 ")

print(arr[0:2, 2])

print("\n\n From both elements, slice index 1 to index 4 (not included), this␣
↪will return a 2-D array ")

print(arr[0:2, 1:4])

Slice elements from index 1 to index 5

[2 3 4 5]

Slice elements from index 4 to the end of the array

[5 6 7]

Slice elements from the beginning to index 4 (not included)

[1 2 3 4]

Slice from the index 3 from the end to index 1 from the end
[5 6]

**Slice from the index 3 from the end to index 1 from the end
[5 6 7]

Slice every other element from index 1 to index 5

[2 4]

12
 Slice every other element from the entire array
[1 3 5 7]

*******************Slicing 2-D Arrays **************************

From the second element, slice elements from index 1 to index 4 (not included)
[7 8 9]

From both elements, return index 2

[3 8]

From both elements, slice index 1 to index 4 (not included), this will return a
2-D array
[[2 3 4]
[7 8 9]]

[27]: #---------------------------------------------------------------------------------------------

#array reshping
#Array Reshaping

#Convert the following 1-D array with 12 elements into a 2-D array.
#The outermost dimension will have 4 arrays, each with 3 elements:

import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])

newarr = arr.reshape(4, 3)
print("\n\n 1-D array with 12 elements into a 2-D array \n")
print(newarr)

#Convert the following 1-D array with 12 elements into a 3-D array.
#The outermost dimension will have 2 arrays that contains 3 arrays, each with 2␣
↪elements:

newarr = arr.reshape(2, 3, 2)
print("\n\n 1-D array with 12 elements into a 3-D array \n")
print(newarr)

'''Unknown Dimension
You are allowed to have one "unknown" dimension.

13
Meaning that you do not have to specify an exact number for one of the␣
↪dimensions in the reshape method.

Pass -1 as the value, and NumPy will calculate this number for you.'''

#Convert 1D array with 8 elements to 3D array with 2x2 elements:

newarr = arr.reshape(2, 2, -1)
print("\n\n 1-D array with 8 elements into a 3-D array \n")
print(newarr)

'''
Flattening the arrays
Flattening array means converting a multidimensional array into a 1D array.
We can use reshape(-1) to do this.'''

arr = np.array([[1, 2, 3], [4, 5, 6]])

newarr = arr.reshape(-1)
print("\n\n Flattened array \n")
print(newarr)

1-D array with 12 elements into a 2-D array

[[ 1 2 3]
[ 4 5 6]
[ 7 8 9]
[10 11 12]]

1-D array with 12 elements into a 3-D array

[[[ 1 2]
[ 3 4]
[ 5 6]]

[[ 7 8]
[ 9 10]
[11 12]]]

1-D array with 8 elements into a 3-D array

[[[ 1 2 3]
[ 4 5 6]]

[[ 7 8 9]
[10 11 12]]]

14
 Flattened array

[1 2 3 4 5 6]

[29]: #Arrayindexing
import numpy as np

arr = np.array([1, 2, 3, 4])

print("\n\n Get the first element \n")

print(arr[0])

print("\n\n Get the second element \n")

print(arr[1])

print("\n\n Get additon of the third element and fourth element \n")
print(print(arr[2] + arr[3]))

print("\n\n ****************2D Array Indexing **************")

arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])

print("\n\n Access the element on the first row, second column \n")
print('2nd element on 1st row: ', arr[0, 1])

print('5th element on 2nd row: ', arr[1, 4])

print("\n\n ****************3D Array Indexing **************")

arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])

print("\n\n Access the third element of the second array of the first array \n")
print(arr[0, 1, 2])

'''
The first number represents the first dimension, which contains two arrays:
[[1, 2, 3], [4, 5, 6]]
and:
[[7, 8, 9], [10, 11, 12]]
Since we selected 0, we are left with the first array:
[[1, 2, 3], [4, 5, 6]]

The second number represents the second dimension, which also contains two␣
↪arrays:

[1, 2, 3]

15
and:
[4, 5, 6]
Since we selected 1, we are left with the second array:
[4, 5, 6]

The third number represents the third dimension, which contains three values:
4
5
6
Since we selected 2, we end up with the third value:
6
'''
arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])
print("\nPrint the last element from the 2nd dimension \n")
print('Last element from 2nd dim: ', arr[1, -1])

arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

print(arr[1, 1, 0])

Get the first element

Get the second element

Get additon of the third element and fourth element

7
None

****************2D Array Indexing **************

Access the element on the first row, second column

2nd element on 1st row: 2

5th element on 2nd row: 10

****************3D Array Indexing **************

16
 Access the third element of the second array of the first array

Print the last element from the 2nd dimension

Last element from 2nd dim: 10

7

[31]: #ARRAY CREATION

# Python program to demonstrate
# array creation techniques
import numpy as np

# Creating array from list with type float

a = np.array([[1, 2, 4], [5, 8, 7]], dtype='float')
print("Array created using passed list:\n", a)

# Creating array from tuple

b = np.array((1, 3, 2))
print("\nArray created using passed tuple:\n", b)

# Creating a 3X4 array with all zeros

c = np.zeros((3, 4))
print("\nAn array initialized with all zeros:\n", c)

# Create a constant value array of complex type

d = np.full((3, 3), 6, dtype='complex')
print("\nAn array initialized with all 6s."
"Array type is complex:\n", d)

# Python program to demonstrate

# basic array characteristics
import numpy as np

# Creating array object

arr = np.array([[1, 2, 3],
[4, 2, 5]])

print("Array is \n: ", arr)

# Printing type of arr object
print("Array is of type: ", type(arr))

# Printing array dimensions (axes)

17
 print("No. of dimensions: ", arr.ndim)

# Printing shape of array

print("Shape of array: ", arr.shape)

# Printing size (total number of elements) of array

print("Size of array: ", arr.size)

# Printing type of elements in array

print("Array stores elements of type: ", arr.dtype)

Array created using passed list:

[[1. 2. 4.]
[5. 8. 7.]]

Array created using passed tuple:

[1 3 2]

An array initialized with all zeros:

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

An array initialized with all 6s.Array type is complex:

[[6.+0.j 6.+0.j 6.+0.j]
[6.+0.j 6.+0.j 6.+0.j]
[6.+0.j 6.+0.j 6.+0.j]]
Array is
: [[1 2 3]
[4 2 5]]
Array is of type: <class 'numpy.ndarray'>
No. of dimensions: 2
Shape of array: (2, 3)
Size of array: 6
Array stores elements of type: int32

[33]: #Array concatenation1

#Array Concatenation1

# importing numpy as np
import numpy as np

arr1 = np.array([[[1, 2], [3, 4]],[[5, 6],[7,8]]])

arr2 = np.array([[[9, 10], [11, 12]],[[13, 14],[15,16]]])
#Concatenating along rows
gfg = np.concatenate((arr1, arr2), axis = 0)
print("\n\n Concatenating along rows (axis=0)")

18
print (gfg)

#Concatenating along Columnss

gfg = np.concatenate((arr1, arr2), axis = 1)
print("\n\n Concatenating along columns (axis=1)")
print (gfg)

#Concatenating as flattened array

gfg = np.concatenate((arr1, arr2), axis = None)
print("\n\n Concatenating as flattened array")
print (gfg)

print ("\n **************** stack() demo *******")

arr1 = np.array([[[1, 2], [3, 4]],[[5, 6],[7,8]]])
arr2 = np.array([[[9, 10], [11, 12]],[[13, 14],[15,16]]])
arr = np.stack((arr1, arr2), axis=1)
print("\n\n Concatenation using stack()")
print(arr)

#hstack() to stack along rows.

arr = np.hstack((arr1, arr2))
print("\n\n Horizontal Stacking using hstack()")
print(arr)

#vstack() to stack along Columns.

arr = np.vstack((arr1, arr2))
print("\n\n Vertical Stacking using vstack()")
print(arr)

Concatenating along rows (axis=0)

[[[ 1 2]
[ 3 4]]

[[ 5 6]
[ 7 8]]

[[ 9 10]
[11 12]]

[[13 14]
[15 16]]]

19
 Concatenating along columns (axis=1)
[[[ 1 2]
[ 3 4]
[ 9 10]
[11 12]]

[[ 5 6]
[ 7 8]
[13 14]
[15 16]]]

Concatenating as flattened array

[ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]

**************** stack() demo *******

Concatenation using stack()

[[[[ 1 2]
[ 3 4]]

[[ 9 10]
[11 12]]]

[[[ 5 6]
[ 7 8]]

[[13 14]
[15 16]]]]

Horizontal Stacking using hstack()

[[[ 1 2]
[ 3 4]
[ 9 10]
[11 12]]

[[ 5 6]
[ 7 8]
[13 14]
[15 16]]]

Vertical Stacking using vstack()

[[[ 1 2]
[ 3 4]]

20
 [[ 5 6]
[ 7 8]]

[[ 9 10]
[11 12]]

[[13 14]
[15 16]]]

[35]: #ARRAY CONCATENATION

#Array Concatenation

# importing numpy as np
import numpy as np

arr1 = np.array([[2, 4], [6, 8]])

arr2 = np.array([[3, 5], [7, 9]])
#Concatenating along rows
gfg = np.concatenate((arr1, arr2), axis = 0)
print("\n\n Concatenating along rows (axis=0)")
print (gfg)

#Concatenating along Columnss

gfg = np.concatenate((arr1, arr2), axis = 1)
print("\n\n Concatenating along columns (axis=1)")
print (gfg)

#Concatenating as flattened array

gfg = np.concatenate((arr1, arr2), axis = None)
print("\n\n Concatenating as flattened array")
print (gfg)

print ("\n **************** stack() demo *******")

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
arr = np.stack((arr1, arr2), axis=1)
print("\n\n Concatenation using stack()")
print(arr)

#hstack() to stack along rows.

arr = np.hstack((arr1, arr2))
print("\n\n Horizontal Stacking using hstack()")
print(arr)

21
 #vstack() to stack along Columns.
arr = np.vstack((arr1, arr2))
print("\n\n Vertical Stacking using vstack()")
print(arr)

Concatenating along rows (axis=0)

[[2 4]
[6 8]
[3 5]
[7 9]]

Concatenating along columns (axis=1)

[[2 4 3 5]
[6 8 7 9]]

Concatenating as flattened array

[2 4 6 8 3 5 7 9]

**************** stack() demo *******

Concatenation using stack()

[[1 4]
[2 5]
[3 6]]

Horizontal Stacking using hstack()

[1 2 3 4 5 6]

Vertical Stacking using vstack()

[[1 2 3]
[4 5 6]]

[ ]:

22