Numpy

Numpy - Numerical Python Numpy - is a python library which have inbuilt functions to perform operations on numerical data. Mostly numpy library functions used to perform operations on arrays. Array : array a collection of
similar data type items (homogeneous data items) Numpy arrays are 50x times faster than python list Numpy library is a foundation all other python libraries like pandas,scipy,matplotlib and so..
In [6]: # install numpy
# pip install numpy

Importing numpy library

In [2]: import numpy as np

Creating a numpy array

In [3]: a = np.array([23,45,67,89,12,46])

In [4]: a

Out[4]: array([23, 45, 67, 89, 12, 46])

In [5]: a.dtype # data type of items in an array

Out[5]: dtype('int64')

In [13]: type(a) # type of variable

Out[13]: numpy.ndarray

In [14]: a.shape #shape of an array

Out[14]: (6,)

In [15]: a.size #size of an array

Out[15]: 6

In [16]: a.itemsize # bytes occupied by each item in an array

Out[16]: 8

In [17]: a.ndim # dimension of an array

Out[17]: 1

In [18]: a.nbytes # number of bytes occupied by all array itemss

Out[18]: 48

In [19]: a.data # memory location where array stored

Out[19]: <memory at 0x106cefac0>

In [20]: L = [3,6,7,9,2,4]

a1 = np.array(L)

In [21]: a1

Out[21]: array([3, 6, 7, 9, 2, 4])

Creating 2D array
In [6]: a3 = np.array([[23,26,29],[8,6,9],[10,12,13]])

In [7]: a3.ndim # dimensions

Out[7]: 2

In [8]: a3.shape

Out[8]: (3, 3)

In [9]: a3.size

Out[9]: 9

In [10]: a3.nbytes

Out[10]: 72

In [11]: a3.itemsize

Out[11]: 8

numpy array indexing

Numpy array items can be accessed by referring to their index value
In [13]: a

Out[13]: array([23, 45, 67, 89, 12, 46])

In [14]: a[0]

Out[14]: 23

In [15]: a[1]

Out[15]: 45

In [16]: a[-1]

Out[16]: 46

In [17]: a[-2]# accessing items with negative index

Out[17]: 12

In [18]: a[::]

Out[18]: array([23, 45, 67, 89, 12, 46])

In [19]: a[:] # all items of an arrya

Out[19]: array([23, 45, 67, 89, 12, 46])

In [20]: a[::-1] # array items in reverse order

Out[20]: array([46, 12, 89, 67, 45, 23])

In [38]: a[1:6:2] # step size

Out[38]: array([45, 89, 46])

In [39]: a

Out[39]: array([23, 45, 67, 89, 12, 46])

In [40]: a[1:5] # slicing

Out[40]: array([45, 67, 89, 12])

In [21]: a3

Out[21]: array([[23, 26, 29],

[ 8, 6, 9],
[10, 12, 13]])

In [22]: a3[0,1]

Out[22]: 26

In [23]: a3[0,0]

Out[23]: 23

In [24]: a3[0,2]

Out[24]: 29

In [25]: a3[1,-1]

Out[25]: 9

In [26]: a3[-2,-1]

Out[26]: 9

In [47]: #creating zeros matrix

In [48]: # zeros() - it returns 0's matrix of given size

In [27]: np.zeros(5)

Out[27]: array([0., 0., 0., 0., 0.])

In [28]: np.zeros([3,3])

Out[28]: array([[0., 0., 0.],

[0., 0., 0.],
[0., 0., 0.]])

In [29]: #creating onces matrix

# ones() - returns 1's matrix of given size

In [30]: np.ones(4)

Out[30]: array([1., 1., 1., 1.])

In [31]: np.ones([4,5])

Out[31]: array([[1., 1., 1., 1., 1.],

[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.]])

In [32]: #arange() - returns a range of values

In [36]: X = np.arange(1,30)
X

Out[36]: array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29])

In [35]: X[X%2==0]

Out[35]: array([ 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

In [37]: X[X%2!=0]

Out[37]: array([ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29])

In [38]: np.linspace(1,100,10)

Out[38]: array([ 1., 12., 23., 34., 45., 56., 67., 78., 89., 100.])

In [39]: a

Out[39]: array([23, 45, 67, 89, 12, 46])

In [40]: a.sum()

Out[40]: 282

In [41]: a.max()

Out[41]: 89

In [42]: a.min()

Out[42]: 12

In [43]: np.median(a)

Out[43]: 45.5

In [ ]:

In [55]: np.arange(1,20)

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

In [56]: c = np.arange(1,10)
print(c)

[1 2 3 4 5 6 7 8 9]

In [58]: c1 = np.arange(1,21)
c1[c1%2==0]

Out[58]: array([ 2, 4, 6, 8, 10, 12, 14, 16, 18, 20])

In [59]: c1[c1%2!=0]

Out[59]: array([ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19])

In [60]: #linspace() - returns linearly spaced elements within a given range

In [61]: np.linspace(1,10,5)

Out[61]: array([ 1. , 3.25, 5.5 , 7.75, 10. ])

In [65]: np.linspace(1,10,20)

Out[65]: array([ 1. , 1.47368421, 1.94736842, 2.42105263, 2.89473684,

3.36842105, 3.84210526, 4.31578947, 4.78947368, 5.26315789,
5.73684211, 6.21052632, 6.68421053, 7.15789474, 7.63157895,
8.10526316, 8.57894737, 9.05263158, 9.52631579, 10. ])

In [66]: #generate 20 evenly spaced items inbetween 1, 100

In [67]: np.linspace(1,100,20)

Out[67]: array([ 1. , 6.21052632, 11.42105263, 16.63157895,

21.84210526, 27.05263158, 32.26315789, 37.47368421,
42.68421053, 47.89473684, 53.10526316, 58.31578947,
63.52631579, 68.73684211, 73.94736842, 79.15789474,
84.36842105, 89.57894737, 94.78947368, 100. ])

In [68]: #full()

In [69]: np.full(5,10)

Out[69]: array([10, 10, 10, 10, 10])

In [70]: #repeat()
np.repeat(5,10)

Out[70]: array([5, 5, 5, 5, 5, 5, 5, 5, 5, 5])

operations on 1D arrays
In [71]: a

Out[71]: array([23, 45, 67, 89, 12, 46])

In [72]: #sum
a.sum()

Out[72]: 282

In [73]: #cummulative sum

a.cumsum()

Out[73]: array([ 23, 68, 135, 224, 236, 282])

In [74]: # min value

a.min()

Out[74]: 12

In [75]: #maximum value

a.max()

Out[75]: 89

In [76]: #index of maximum value

a.argmax()

Out[76]: 3

In [77]: a

Out[77]: array([23, 45, 67, 89, 12, 46])

In [78]: #index of minimum value

a.argmin()

Out[78]: 4

In [79]: #average (mean) of an array

In [80]: a.mean()

Out[80]: 47.0

In [81]: #median of an array

np.median(a)

Out[81]: 45.5

creating random values

In [82]: #generating random values

In [44]: np.random.random(10)

Out[44]: array([0.56742655, 0.95522925, 0.31790343, 0.91788618, 0.13396117,

0.52284146, 0.023797 , 0.50766087, 0.45726881, 0.05855153])

In [45]: np.random.random(30)

Out[45]: array([0.19749195, 0.41113107, 0.95258106, 0.76736229, 0.50897787,

0.22130199, 0.85451464, 0.60470718, 0.86612788, 0.73075125,
0.72983475, 0.1332484 , 0.1614016 , 0.55041789, 0.9260075 ,
0.61588485, 0.33244735, 0.15769694, 0.80808707, 0.9969559 ,
0.33954457, 0.2614448 , 0.64136551, 0.54631842, 0.11880323,
0.60000456, 0.83304794, 0.48402425, 0.13330854, 0.13197478])

In [46]: np.random.random([5,5])

Out[46]: array([[0.38936638, 0.42318062, 0.29499719, 0.24422862, 0.73499529],

[0.887636 , 0.89549833, 0.88992256, 0.16087972, 0.5812402 ],
[0.8706422 , 0.60444954, 0.60190356, 0.09409241, 0.64371348],
[0.29560583, 0.44313154, 0.02546117, 0.47708874, 0.3452924 ],
[0.62138906, 0.31733976, 0.88504617, 0.84972791, 0.29445919]])

In [47]: np.random.random(25).reshape([5,5])

Out[47]: array([[0.20898456, 0.95944472, 0.78804827, 0.52959761, 0.64039612],

[0.52199599, 0.67694087, 0.48852139, 0.15647612, 0.53644296],
[0.52313871, 0.05347461, 0.87714845, 0.3089786 , 0.65025445],
[0.3535087 , 0.55422342, 0.48981366, 0.38176314, 0.83491885],
[0.32088775, 0.80524043, 0.7038651 , 0.02077179, 0.40592932]])

In [48]: np.random.randint(1,100,5)

Out[48]: array([43, 59, 77, 7, 43])

In [57]: np.random.seed(4)
np.random.randint(2000,4000,10)

Out[57]: array([3146, 2174, 2439, 2709, 3921, 2360, 3623, 2456, 2818, 2393])

In [58]: np.random.seed(4)
np.random.randint(2000,4000,10)

Out[58]: array([3146, 2174, 2439, 2709, 3921, 2360, 3623, 2456, 2818, 2393])

In [56]: np.linspace(1,20,5)

Out[56]: array([ 1. , 5.75, 10.5 , 15.25, 20. ])

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [55]: np.random.random(10)

Out[55]: array([0.68622209, 0.1671392 , 0.39244247, 0.61805235, 0.41193009,

0.00246488, 0.88403218, 0.88494754, 0.30040969, 0.58958187])

In [85]: np.random.random([3,3]) # 3 rows 3 cols random numbers

Out[85]: array([[0.76547656, 0.41254283, 0.63278187],

[0.20528547, 0.46757755, 0.04203496],
[0.51345125, 0.87812504, 0.40770125]])

In [86]: np.random.random(10)

Out[86]: array([0.20360885, 0.37111588, 0.08449145, 0.56402441, 0.44037428,

0.67370006, 0.79290326, 0.64313817, 0.25026484, 0.38013903])

In [87]: np.random.random(10)

Out[87]: array([0.66103554, 0.93215459, 0.46247992, 0.72866517, 0.35020619,

0.10138322, 0.86858607, 0.62025554, 0.72819704, 0.83800884])

In [89]: np.random.seed(23)
np.random.random(10)

Out[89]: array([0.51729788, 0.9469626 , 0.76545976, 0.28239584, 0.22104536,

0.68622209, 0.1671392 , 0.39244247, 0.61805235, 0.41193009])

In [93]: np.random.seed(23)
np.random.random(10)

Out[93]: array([0.51729788, 0.9469626 , 0.76545976, 0.28239584, 0.22104536,

0.68622209, 0.1671392 , 0.39244247, 0.61805235, 0.41193009])

In [94]: #generate n random integers with in a given range

np.random.randint(1,100,5)

Out[94]: array([76, 86, 70, 65, 13])

In [95]: np.random.randint(100,500,2)

Out[95]: array([121, 148])

In [97]: np.random.seed(2)
np.random.randint(1000,1500,1)

Out[97]: array([1168])

In [98]: np.random.seed(2)
np.random.randint(1000,1500,1)

Out[98]: array([1168])

Operations on 2D array
In [59]: a = np.array([[3,4,5],[6,7,8],[9,6,3]])

In [60]: a

Out[60]: array([[3, 4, 5],

[6, 7, 8],
[9, 6, 3]])

In [61]: a.sum()

Out[61]: 51

In [62]: a.min()

Out[62]: 3

In [63]: a.max()

Out[63]: 9

In [64]: a.mean()

Out[64]: 5.666666666666667

In [65]: np.median(a)

Out[65]: 6.0

In [66]: a.sum(axis=1)

Out[66]: array([12, 21, 18])

In [67]: a.sum(axis=0)

Out[67]: array([18, 17, 16])

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [100… a

Out[100]: array([[3, 4, 5],

[6, 7, 8],
[9, 6, 3]])

In [101… #sum of all elements

a.sum()

Out[101]: 51

In [102… #minimum value in 2d array

a.min()

Out[102]: 3

In [103… #maximum number in 2d array

a.max()

Out[103]: 9

In [104… #columnwise minimum

np.amin(a,axis=0) # axis = 0 ===> columns,axis =1 ===> rows

Out[104]: array([3, 4, 3])

In [105… a

Out[105]: array([[3, 4, 5],

[6, 7, 8],
[9, 6, 3]])

In [106… #row wise minimum

np.amin(a,axis=1)

Out[106]: array([3, 6, 3])

In [107… a

Out[107]: array([[3, 4, 5],

[6, 7, 8],
[9, 6, 3]])

In [109… #columnwise sum

np.sum(a,axis=0)

Out[109]: array([18, 17, 16])

In [110… #rowwise sum

np.sum(a,axis=1)

Out[110]: array([12, 21, 18])

In [111… #mean of 2d array

a.mean()

Out[111]: 5.666666666666667

In [112… #median of 2d array

np.median(a)

Out[112]: 6.0

In [113… #variance
a.var()

Out[113]: 4.0

In [114… #standard deviation

a.std()

Out[114]: 2.0

In [115… #reshaping an array

In [116… #array of 15 values

b = np.arange(1,16)

In [117… b

Out[117]: array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])

In [118… len(b)

Out[118]: 15

In [119… b.ndim

Out[119]: 1

In [120… np.reshape(b,[5,3])

Out[120]: array([[ 1, 2, 3],

[ 4, 5, 6],
[ 7, 8, 9],
[10, 11, 12],
[13, 14, 15]])

In [121… #create an array of 10 random integer values which are between

# 250 t0 300 and arrange them in a 2 rows 5 columns matrix

In [122… ran_values = np.random.randint(250,300,10)

In [123… ran_values

Out[123]: array([265, 295, 258, 272, 293, 268, 261, 290, 257, 284])

In [124… np.reshape(ran_values,[2,5])

Out[124]: array([[265, 295, 258, 272, 293],

[268, 261, 290, 257, 284]])

In [125… #create an array of values ranges from 200 to 300 and return only even
# numbers
values = np.arange(200,301)

In [126… values

Out[126]: array([200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212,
213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238,
239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251,
252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264,
265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277,
278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290,
291, 292, 293, 294, 295, 296, 297, 298, 299, 300])

In [127… values[values%2==0]

Out[127]: array([200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224,
226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250,
252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276,
278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300])

replacing values in an array

In [68]: a = np.arange(1,20)

In [69]: a

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

In [72]: np.where(a%2==0,100,a)

Out[72]: array([ 1, 100, 3, 100, 5, 100, 7, 100, 9, 100, 11, 100, 13,
100, 15, 100, 17, 100, 19])

In [73]: a

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

In [76]: np.where(a%2!=0,200,a)

Out[76]: array([200, 2, 200, 4, 200, 6, 200, 8, 200, 10, 200, 12, 200,
14, 200, 16, 200, 18, 200])

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [129… a

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

In [132… np.where(a%2==0,0,a)

Out[132]: array([ 1, 0, 3, 0, 5, 0, 7, 0, 9, 0, 11, 0, 13, 0, 15, 0, 17,

0, 19])

In [133… #create an array consisting of values 1 to 20 , replace odd numbers

#with a string 'odd'

In [134… np.where(a%2!=0,'odd',a)

Out[134]: array(['odd', '2', 'odd', '4', 'odd', '6', 'odd', '8', 'odd', '10', 'odd',
'12', 'odd', '14', 'odd', '16', 'odd', '18', 'odd'], dtype='<U21')

In [135… b = np.array([10,10,10,30,45,67,10,89,10,30,10,67])

In [137… b

Out[137]: array([10, 10, 10, 30, 45, 67, 10, 89, 10, 30, 10, 67])

In [138… #replace 10 with 999 in an array b

In [139… np.where(b==10,999,b)

Out[139]: array([999, 999, 999, 30, 45, 67, 999, 89, 999, 30, 999, 67])

In [140… np.put(b,[0,1,2],[99,999,999])

In [141… b

Out[141]: array([ 99, 999, 999, 30, 45, 67, 10, 89, 10, 30, 10, 67])

In [142… #replacing an aray items by their index values

In [143… a

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

In [144… np.put(a,[0,2,5],[1000])

In [145… a

Out[145]: array([1000, 2, 1000, 4, 5, 1000, 7, 8, 9, 10, 11,

12, 13, 14, 15, 16, 17, 18, 19])

Converting data type of an array

In [148… a = np.array([[20.2,45.0,78.4],[30.9,89.7,43.6],[1.3,3.4,5.6]])

In [149… a

Out[149]: array([[20.2, 45. , 78.4],

[30.9, 89.7, 43.6],
[ 1.3, 3.4, 5.6]])

In [150… a.astype(int)

Out[150]: array([[20, 45, 78],

[30, 89, 43],
[ 1, 3, 5]])

In [151… a.astype(str)

Out[151]: array([['20.2', '45.0', '78.4'],

['30.9', '89.7', '43.6'],
['1.3', '3.4', '5.6']], dtype='<U32')

Missing values in an array

In [152… a = np.array([10,np.nan,34,90,np.nan,56,36,np.nan])

In [153… a

Out[153]: array([10., nan, 34., 90., nan, 56., 36., nan])

In [158… #searching for missing values an returns a boolean array

np.isnan(a)

Out[158]: array([False, True, False, False, True, False, False, True])

In [159… #index of nan values

np.where(np.isnan(a))

Out[159]: (array([1, 4, 7]),)

In [160… #replace missing values

a[np.isnan(a)]=90

In [161… a

Out[161]: array([10., 90., 34., 90., 90., 56., 36., 90.])

In [162… #check if array have any nan values

np.isnan(a).any()

Out[162]: False

stack arrays vertically

In [164… a = np.array([[1,2,3],[4,5,6]])
b = np.array([[7,8,9],[10,11,12]])

In [165… a

Out[165]: array([[1, 2, 3],

[4, 5, 6]])

In [166… b

Out[166]: array([[ 7, 8, 9],

[10, 11, 12]])

In [167… np.vstack([a,b])

Out[167]: array([[ 1, 2, 3],

[ 4, 5, 6],
[ 7, 8, 9],
[10, 11, 12]])

stack arrays horizontally

In [168… np.hstack([a,b])

Out[168]: array([[ 1, 2, 3, 7, 8, 9],

[ 4, 5, 6, 10, 11, 12]])

process elements on conditions

In [169… a = np.array([10,30,40,50,89,56,34])
b = np.array([10,45,67,50,80,23,34])

In [170… #get indexes where a == b

In [171… np.where(a==b) #

Out[171]: (array([0, 3, 6]),)

In [172… #return an array where condition is satisfied

a[np.where(a==b)]

Out[172]: array([10, 50, 34])

In [173… #return all numbers between 20 and 35 in a array of 1 to 60 values

In [ ]: # a1 = np.arange(1,60)
a1[np.where ((a1>20) & (a1<35))]

In [178… #returns all numbers which are betwen 20 and 35 or divisible by 10

In [180… a1[np.where (((a1>20) & (a1<35)) | (a1%10==0))]

Out[180]: array([10, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 40,
50])

checking for elements in an array using isin()

In [181… A = np.array([12,10,34,11,89,80,56])

In [182… A

Out[182]: array([12, 10, 34, 11, 89, 80, 56])

In [183… #check whether numbers 10 and 11 are present in an array

In [184… np.isin(A,[10,11])

Out[184]: array([False, True, False, True, False, False, False])

In [185… A[np.isin(A,[10,11])]

Out[185]: array([10, 11])

In [186… A[np.isin(A,[50,60])]

Out[186]: array([], dtype=int64)

reverse an array
In [187… a = np.arange(1,10)

In [188… a

Out[188]: array([1, 2, 3, 4, 5, 6, 7, 8, 9])

In [189… a[::-1]

Out[189]: array([9, 8, 7, 6, 5, 4, 3, 2, 1])

In [191… np.flip(a) # to reverse an array

Out[191]: array([9, 8, 7, 6, 5, 4, 3, 2, 1])

In [193… a = np.array([[34,56,78],[67,12,45],[89,79,90]])

In [194… a

Out[194]: array([[34, 56, 78],

[67, 12, 45],
[89, 79, 90]])

In [195… #reverse row positions

a[::-1,]

Out[195]: array([[89, 79, 90],

[67, 12, 45],
[34, 56, 78]])

In [196… #reverse column positions

In [197… a[:,::-1]

Out[197]: array([[78, 56, 34],

[45, 12, 67],
[90, 79, 89]])

In [198… a

Out[198]: array([[34, 56, 78],

[67, 12, 45],
[89, 79, 90]])

In [199… #reverse rows and col positions

In [200… a[::-1,::-1]

Out[200]: array([[90, 79, 89],

[45, 12, 67],
[78, 56, 34]])

In [201… a

Out[201]: array([[34, 56, 78],

[67, 12, 45],
[89, 79, 90]])

sorting an array
In [203… a = np.array([23,12,1,34,9,56,11])

In [204… a

Out[204]: array([23, 12, 1, 34, 9, 56, 11])

In [205… np.sort(a)

Out[205]: array([ 1, 9, 11, 12, 23, 34, 56])

In [206… b = np.array([[34,56,78],[67,12,45],[89,79,90]])

In [207… b

Out[207]: array([[34, 56, 78],

[67, 12, 45],
[89, 79, 90]])

In [208… np.sort(b,axis=0) #column wise sorting

Out[208]: array([[34, 12, 45],

[67, 56, 78],
[89, 79, 90]])

In [210… np.sort(b,axis=1)

Out[210]: array([[34, 56, 78],

[12, 45, 67],
[79, 89, 90]])

frequent values in an array

In [211… a = np.array([10,10,20,10,20,30,30,30,10,20])

In [212… np.unique(a)

Out[212]: array([10, 20, 30])

In [213… val,count = np.unique(a,return_counts=True)

val,count

Out[213]: (array([10, 20, 30]), array([4, 3, 3]))

In [214… #Generate random 30 integers between 100 to 300 and return the numbers
#which are divisible by 4 and inbetween 150 to 250

In [215… N = np.random.randint(100,300,30)

In [216… N

Out[216]: array([277, 195, 175, 147, 163, 131, 248, 224, 216, 137, 267, 295, 202,
104, 270, 207, 151, 203, 138, 133, 158, 224, 167, 169, 188, 296,
146, 298, 195, 221])

In [217… N[(N%4==0) & (N>150) & (N<250)]

Out[217]: array([248, 224, 216, 224, 188])

In [218… #Generate 100 random numbers and return the values which are greater
#than 0.2 and less than 0.5

In [220… n = np.random.random(100)

In [222… n[(n>0.2) & (n<0.5)]

Out[222]: array([0.226012 , 0.22030621, 0.34982629, 0.46778748, 0.20174323,

0.48306984, 0.38689265, 0.34161365, 0.42754596, 0.43674726,
0.3663424 , 0.40627504, 0.24717724, 0.29302323, 0.35662428,
0.44135492, 0.32354132, 0.25974475, 0.38688989, 0.37921057,
0.2693888 , 0.38752343, 0.4970738 , 0.41490584, 0.3508719 ,
0.31325853, 0.21463575, 0.41675344, 0.22083792, 0.34623791,
0.26377853, 0.41973546, 0.48926617, 0.24581116])

Indentity matrix
In [225… np.eye(4)

Out[225]: array([[1., 0., 0., 0.],

[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]])

In [226… np.eye(6)

Out[226]: array([[1., 0., 0., 0., 0., 0.],

[0., 1., 0., 0., 0., 0.],
[0., 0., 1., 0., 0., 0.],
[0., 0., 0., 1., 0., 0.],
[0., 0., 0., 0., 1., 0.],
[0., 0., 0., 0., 0., 1.]])

diagonal Matrix
In [227… np.diag([1,2,3,4])

Out[227]: array([[1, 0, 0, 0],

[0, 2, 0, 0],
[0, 0, 3, 0],
[0, 0, 0, 4]])

In [228… np.diag([10,20,30])

Out[228]: array([[10, 0, 0],

[ 0, 20, 0],
[ 0, 0, 30]])

Matrix Addition
In [232… a = np.arange(10,20)
a1 = np.reshape(a,[5,2])

b = np.arange(30,40)
b1 = np.reshape(b,[5,2])

In [233… a1

Out[233]: array([[10, 11],

[12, 13],
[14, 15],
[16, 17],
[18, 19]])

In [234… b1

Out[234]: array([[30, 31],

[32, 33],
[34, 35],
[36, 37],
[38, 39]])

In [235… a1 + b1

Out[235]: array([[40, 42],

[44, 46],
[48, 50],
[52, 54],
[56, 58]])

Numpy Array Broadcasting

In [236… a = np.array([[10,20,30],[40,50,60],[70,80,90]])

In [237… a

Out[237]: array([[10, 20, 30],

[40, 50, 60],
[70, 80, 90]])

In [238… b = np.array([10,20,30])

In [239… b

Out[239]: array([10, 20, 30])

In [240… a+b

Out[240]: array([[ 20, 40, 60],

[ 50, 70, 90],
[ 80, 100, 120]])

In [241… c = np.arange(10,30).reshape(4,5)

In [242… c

Out[242]: array([[10, 11, 12, 13, 14],

[15, 16, 17, 18, 19],
[20, 21, 22, 23, 24],
[25, 26, 27, 28, 29]])

In [243… c.reshape(-1) # multidimensional array to 1D array

Out[243]: array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
27, 28, 29])

In [244… c.ravel() #multidimensional array to 1D array - eqivalent to reshape(-1)

Out[244]: array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
27, 28, 29])

In [245… c

Out[245]: array([[10, 11, 12, 13, 14],

[15, 16, 17, 18, 19],
[20, 21, 22, 23, 24],
[25, 26, 27, 28, 29]])

In [246… c.flatten()

Out[246]: array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
27, 28, 29])

Transpose of a matrix
In [247… a = np.array([[3,4,5],[5,6,7]])

In [248… np.transpose(a)

Out[248]: array([[3, 5],

[4, 6],
[5, 7]])

matrix multiplication (. product)

In [257… b = np.arange(10,20).reshape(5,2)

In [255… c = np.arange(20,30).reshape(5,2)

In [258… b,c

Out[258]: (array([[10, 11],

[12, 13],
[14, 15],
[16, 17],
[18, 19]]),
array([[20, 21],
[22, 23],
[24, 25],
[26, 27],
[28, 29]]))

In [259… b * c

Out[259]: array([[200, 231],

[264, 299],
[336, 375],
[416, 459],
[504, 551]])

Append arrays
In [260… a = np.array([3,4,5])
b = np.array([6,7,8])

np.append(a,b)

Out[260]: array([3, 4, 5, 6, 7, 8])

In [261… import numpy as np

In [262… np.__version__ #version

Out[262]: '1.23.5'

In [263… #write a code to test none of the elements in an array are zero

In [264… a

Out[264]: array([3, 4, 5])

In [266… a.all()

Out[266]: True

In [267… b = np.array([0,3,4,5])
b.all()

Out[267]: False

In [ ]: #write numpy code to broadcast a 4 elements 1d array to 4x4 multidimens

#onal array

In [272… a = np.arange(10,26).reshape([4,4])

In [273… a

Out[273]: array([[10, 11, 12, 13],

[14, 15, 16, 17],
[18, 19, 20, 21],
[22, 23, 24, 25]])

In [274… b = np.array([1,2,3,4])

In [275… a+b

Out[275]: array([[11, 13, 15, 17],

[15, 17, 19, 21],
[19, 21, 23, 25],
[23, 25, 27, 29]])

In [276… a = np.array([[1,2,3],[4,5,6]])

In [277… a

Out[277]: array([[1, 2, 3],

[4, 5, 6]])

In [278… b = np.array([1,2,3])

In [279… a,b

Out[279]: (array([[1, 2, 3],

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

In [280… a*b

Out[280]: array([[ 1, 4, 9],

[ 4, 10, 18]])

In [281… # w.a.numpy code to add an ones matrix to a 3x3 matrix and show
#resultant matrix as flattend array

In [283… a = np.arange(1,10).reshape([3,3])

In [284… a

Out[284]: array([[1, 2, 3],

[4, 5, 6],
[7, 8, 9]])

In [287… O = np.ones(9).reshape([3,3])

In [288… O

Out[288]: array([[1., 1., 1.],

[1., 1., 1.],
[1., 1., 1.]])

In [289… result = a+O

In [290… result

Out[290]: array([[ 2., 3., 4.],

[ 5., 6., 7.],
[ 8., 9., 10.]])

In [291… result.flatten()

Out[291]: array([ 2., 3., 4., 5., 6., 7., 8., 9., 10.])

In [292… np.ones([3,3])

Out[292]: array([[1., 1., 1.],

[1., 1., 1.],
[1., 1., 1.]])

In [295… result = (np.arange(1,10).reshape([3,3])+np.ones([3,3])).flatten()

In [296… result

Out[296]: array([ 2., 3., 4., 5., 6., 7., 8., 9., 10.])

In [297… np.full([3,3],7)

Out[297]: array([[7, 7, 7],

[7, 7, 7],
[7, 7, 7]])
#w.a. numpy program to create a 10x10 matrix , in which the elements on the borders will be equal to 1 and inside zero ex : 1 1 1 1 1 0 0 1 1 0 0 1 1 1 1 1
In [298… a = np.ones([10,10])

In [299… a

Out[299]: array([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]])

In [300… a[1:-1,1:-1]=0

In [301… a

Out[301]: array([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]])
W.a. numpy code to create a 5x5 zero matrix with the elements on the diagonal equal to 1,2,3,4,5
In [302… np.diag([1,2,3,4,5])

Out[302]: array([[1, 0, 0, 0, 0],

[0, 2, 0, 0, 0],
[0, 0, 3, 0, 0],
[0, 0, 0, 4, 0],
[0, 0, 0, 0, 5]])

In [303… #create a 3x3 matrix of random integers between 30 - 50 and add (1x3) matrix of random
#numbers(integers) between 1 - 10.

In [305… a = np.random.randint(30,50,9).reshape([3,3])
b = np.random.randint(1,10,3)
a+b

Out[305]: array([[53, 56, 51],

[39, 52, 34],
[41, 42, 50]])

In [306… a

Out[306]: array([[47, 49, 49],

[33, 45, 32],
[35, 35, 48]])

In [307… b

Out[307]: array([6, 7, 2])

In [308… a*b

Out[308]: array([[282, 343, 98],

[198, 315, 64],
[210, 245, 96]])

In [309… a,b

Out[309]: (array([[47, 49, 49],

[33, 45, 32],
[35, 35, 48]]),
array([6, 7, 2]))

In [310… #generate a random values matrix of size 10x10 and add ones matrix of same size , return all
#rows expect last row

In [321… result = (np.random.random(100).reshape([10,10]) + np.ones([10,10]))[0:-1]

In [322… result

Out[322]: array([[1.28263579, 1.97811426, 1.69232838, 1.90630381, 1.80738494,

1.43250158, 1.56652893, 1.21915987, 1.68144861, 1.69699513],
[1.33324287, 1.9524343 , 1.34281994, 1.57140455, 1.34664485,
1.45162479, 1.36710875, 1.97957895, 1.5765991 , 1.98822066],
[1.44905011, 1.40606451, 1.06499858, 1.40252464, 1.63932379,
1.93205829, 1.11331532, 1.1031494 , 1.46779616, 1.85730294],
[1.18858465, 1.69426114, 1.27102259, 1.86278811, 1.59476126,
1.52251456, 1.71300285, 1.57545634, 1.68676174, 1.48813529],
[1.74992416, 1.11685838, 1.03153876, 1.4254992 , 1.03015492,
1.19924493, 1.30988937, 1.93715387, 1.19226428, 1.02614912],
[1.2848688 , 1.49974371, 1.19323165, 1.45141687, 1.65920634,
1.34674096, 1.69409576, 1.22950609, 1.45516874, 1.12404601],
[1.62350819, 1.11695604, 1.24968862, 1.87565749, 1.71245256,
1.59157201, 1.96193627, 1.06871678, 1.06179074, 1.1773612 ],
[1.87356134, 1.90743514, 1.72443068, 1.03004253, 1.04683522,
1.39914301, 1.35217626, 1.60182941, 1.85783183, 1.49298354],
[1.45941486, 1.73063294, 1.58737202, 1.74065504, 1.36910424,
1.80772049, 1.36223062, 1.42803479, 1.31431174, 1.06818331]])

In [325… a = np.ones([10,10])

In [326… b = np.random.random(100).reshape([10,10])

In [328… c = a+b
c[:-1]

Out[328]: array([[1.12503716, 1.75342446, 1.97280372, 1.67748213, 1.82262661,

1.69689394, 1.03456885, 1.60427388, 1.2846484 , 1.80929889],
[1.76513077, 1.23351177, 1.76459246, 1.33825409, 1.97686434,
1.85702263, 1.57852815, 1.66252812, 1.89691005, 1.89487813],
[1.95859981, 1.82651758, 1.7658095 , 1.07389364, 1.92494692,
1.74674112, 1.93719762, 1.36013957, 1.8349656 , 1.8788102 ],
[1.48177291, 1.93252553, 1.79956473, 1.75055408, 1.58820565,
1.37260346, 1.0414321 , 1.17286695, 1.14848888, 1.07918005],
[1.05976541, 1.13373198, 1.83997385, 1.58919808, 1.27451811,
1.88931301, 1.91104627, 1.89179008, 1.1142138 , 1.26947819],
[1.54631039, 1.2567671 , 1.39208743, 1.17379121, 1.58244413,
1.89313995, 1.85688144, 1.03131071, 1.28277539, 1.55842322],
[1.2346488 , 1.79579857, 1.64216947, 1.29386329, 1.13021007,
1.60961049, 1.24741702, 1.42961094, 1.02316953, 1.41657319],
[1.60635583, 1.41439513, 1.55977164, 1.92684842, 1.78654683,
1.94343409, 1.9149462 , 1.24369787, 1.06983548, 1.99561 ],
[1.7373638 , 1.39943564, 1.82211567, 1.68495167, 1.26024752,
1.79174359, 1.17078622, 1.97011926, 1.32021805, 1.87598259]])

In [329… #w.a. numpy code to extract all numbers from a given array less and greater than a specified
#number

In [330… a = np.arange(1,21).reshape([4,5])

In [333… a

Out[333]: array([[ 1, 2, 3, 4, 5],

[ 6, 7, 8, 9, 10],
[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20]])

In [331… a[a>10]

Out[331]: array([11, 12, 13, 14, 15, 16, 17, 18, 19, 20])

In [332… a[a<10]

Out[332]: array([1, 2, 3, 4, 5, 6, 7, 8, 9])

In [334… #write numpy code to replace all numbers in a given array which is equal,less and greater
#to a given number

In [335… #array of integers range from 100 - 200 of size 10x10, and specified value is 150

# equal - replace with 10

#less - replace with 100
#greater - replace with 1000

In [337… a = np.arange(100,200).reshape([10,10])

In [340… np.where(a>150,1000,a)

Out[340]: array([[ 100, 101, 102, 103, 104, 105, 106, 107, 108, 109],
[ 110, 111, 112, 113, 114, 115, 116, 117, 118, 119],
[ 120, 121, 122, 123, 124, 125, 126, 127, 128, 129],
[ 130, 131, 132, 133, 134, 135, 136, 137, 138, 139],
[ 140, 141, 142, 143, 144, 145, 146, 147, 148, 149],
[ 150, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000],
[1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000],
[1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000],
[1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000],
[1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000]])

In [341… np.where(a<150,100,a)

Out[341]: array([[100, 100, 100, 100, 100, 100, 100, 100, 100, 100],
[100, 100, 100, 100, 100, 100, 100, 100, 100, 100],
[100, 100, 100, 100, 100, 100, 100, 100, 100, 100],
[100, 100, 100, 100, 100, 100, 100, 100, 100, 100],
[100, 100, 100, 100, 100, 100, 100, 100, 100, 100],
[150, 151, 152, 153, 154, 155, 156, 157, 158, 159],
[160, 161, 162, 163, 164, 165, 166, 167, 168, 169],
[170, 171, 172, 173, 174, 175, 176, 177, 178, 179],
[180, 181, 182, 183, 184, 185, 186, 187, 188, 189],
[190, 191, 192, 193, 194, 195, 196, 197, 198, 199]])

In [342… np.where(a==150,10,a)

Out[342]: array([[100, 101, 102, 103, 104, 105, 106, 107, 108, 109],
[110, 111, 112, 113, 114, 115, 116, 117, 118, 119],
[120, 121, 122, 123, 124, 125, 126, 127, 128, 129],
[130, 131, 132, 133, 134, 135, 136, 137, 138, 139],
[140, 141, 142, 143, 144, 145, 146, 147, 148, 149],
[ 10, 151, 152, 153, 154, 155, 156, 157, 158, 159],
[160, 161, 162, 163, 164, 165, 166, 167, 168, 169],
[170, 171, 172, 173, 174, 175, 176, 177, 178, 179],
[180, 181, 182, 183, 184, 185, 186, 187, 188, 189],
[190, 191, 192, 193, 194, 195, 196, 197, 198, 199]])

In [343… result = np.where(a>150,1000,a)

result = np.where(result<150,100,result)
result = np.where(result==150,10,result)

In [344… result

Out[344]: array([[ 100, 100, 100, 100, 100, 100, 100, 100, 100, 100],
[ 100, 100, 100, 100, 100, 100, 100, 100, 100, 100],
[ 100, 100, 100, 100, 100, 100, 100, 100, 100, 100],
[ 100, 100, 100, 100, 100, 100, 100, 100, 100, 100],
[ 100, 100, 100, 100, 100, 100, 100, 100, 100, 100],
[ 10, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000],
[1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000],
[1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000],
[1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000],
[1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000]])

In [345… #write numpy code to create a 4x4 array (A), now create a new array from the A array swapping
#first and last, second and third columns

In [348… a = np.arange(16).reshape([4,4])

In [349… a

Out[349]: array([[ 0, 1, 2, 3],

[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])

In [350… a[:,::-1]

Out[350]: array([[ 3, 2, 1, 0],

[ 7, 6, 5, 4],
[11, 10, 9, 8],
[15, 14, 13, 12]])

In [351… #write numpy code to swap rows and cols of a given array in reverse order

In [352… a

Out[352]: array([[ 0, 1, 2, 3],

[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])

In [353… a[::-1,::-1]

Out[353]: array([[15, 14, 13, 12],

[11, 10, 9, 8],
[ 7, 6, 5, 4],
[ 3, 2, 1, 0]])

In [363… a = np.arange(10,20).reshape([5,2])
b = np.arange(15,25)

len(a),len(b)

Out[363]: (5, 10)

In [358… a

Out[358]: array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19])

In [359… b

Out[359]: array([15, 16, 17, 18, 19, 20, 21, 22, 23, 24])

In [361… for i in a:
print(i,end=' ')

10 11 12 13 14 15 16 17 18 19

In [364… a

Out[364]: array([[10, 11],

[12, 13],
[14, 15],
[16, 17],
[18, 19]])

In [368… a.shape

Out[368]: (5, 2)

In [369… L = a.shape

In [370… L[0]

Out[370]: 5

In [371… L[1]

Out[371]: 2

In [372… a

Out[372]: array([[10, 11],

[12, 13],
[14, 15],
[16, 17],
[18, 19]])

In [373… for i in np.nditer(a):

print(i)

10
11
12
13
14
15
16
17
18
19

In [374… for i in a.flatten():

print(i)

10
11
12
13
14
15
16
17
18
19

In [376… #write numpy code to iterate over 2D array and return values which are divisible by 4 and
#greater than 25

#a = np.arange(12,60).reshape([12,4])

In [380… for i in np.nditer(np.arange(12,60).reshape([12,4])):

if i %4 == 0 and i > 25:
print(i)

28
32
36
40
44
48
52
56

creating a 3D array
In [390… a = np.array([[[1,2,3],[4,5,6],[7,8,9]],[[10,11,12],[13,14,15],[16,17,18]],[[10,11,12],[13,14,15],[16,17,18]]])

In [391… a

Out[391]: array([[[ 1, 2, 3],

[ 4, 5, 6],
[ 7, 8, 9]],

[[10, 11, 12],

[13, 14, 15],
[16, 17, 18]],

[[10, 11, 12],

[13, 14, 15],
[16, 17, 18]]])

In [396… a = np.array([[[1,2,3],[4,5,6],[7,8,9]],[[1,2,3],[4,5,6],[7,8,9]],[[1,2,3],[4,5,6],[7,8,9]]])

In [397… a

Out[397]: array([[[1, 2, 3],

[4, 5, 6],
[7, 8, 9]],

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

[[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]])

In [398… a.ndim

Out[398]: 3

In [399… a.shape

Out[399]: (3, 3, 3)

In [400… #write a program to create a 2d array of shape (8,5) of random numbers. select random
#numbers from a normal distribution

In [411… np.random.randn(40).reshape([8,5])

Out[411]: array([[-0.54192738, -0.46530982, 2.02795041, -0.86572006, -0.93042348],

[-0.41177318, 0.1345763 , -0.01056192, -0.84705938, 1.90578796],
[-0.42382384, -0.74340629, -0.30917276, -0.25525059, -0.12650922],
[-0.05330437, -1.09488118, 0.56474102, -0.55892742, -0.48557633],
[ 0.06385837, 0.00441547, -0.21884233, -1.32607327, -0.95380284],
[-1.52786554, 0.6530207 , -0.63374411, 0.35883213, 1.55824166],
[ 0.7958125 , 0.29608791, -1.1740912 , 0.79809665, 0.47055316],
[-0.00340114, 0.15723077, 0.12024531, -0.74018088, -0.08890182]])

In [404… np.random.random(10)

Out[404]: array([0.4506998 , 0.39568886, 0.04405472, 0.02350147, 0.45948496,

0.83169943, 0.99111198, 0.03026092, 0.90316217, 0.0318483 ])

In [405… np.random.uniform(10,20,5)

Out[405]: array([11.6437088 , 17.54771922, 19.65129831, 10.57979103, 10.00649134])

In [77]: a = np.arange(10,20).reshape([5,2])

In [80]: import scipy.stats as st

In [81]: st.mode(a)

/var/folders/nn/9bkkh7612wg2c3gglt0zd9h40000gn/T/ipykernel_80656/1319879173.py:1: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default
behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis`
over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.
st.mode(a)
Out[81]: ModeResult(mode=array([[10, 11]]), count=array([[1, 1]]))

In [83]: import statistics as st

In [84]: st.mode(a)

---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[84], line 1
----> 1 st.mode(a)

File ~/anaconda3/lib/python3.10/statistics.py:579, in mode(data)

556 def mode(data):
557 """Return the most common data point from discrete or nominal data.
558
559 ``mode`` assumes discrete data, and returns a single value. This is the
(...)
577
578 """
--> 579 pairs = Counter(iter(data)).most_common(1)
580 try:
581 return pairs[0][0]

File ~/anaconda3/lib/python3.10/collections/__init__.py:577, in Counter.__init__(self, iterable, **kwds)

566 '''Create a new, empty Counter object. And if given, count elements
567 from an input iterable. Or, initialize the count from another mapping
568 of elements to their counts.
(...)
574
575 '''
576 super().__init__()
--> 577 self.update(iterable, **kwds)

File ~/anaconda3/lib/python3.10/collections/__init__.py:670, in Counter.update(self, iterable, **kwds)

668 super().update(iterable)
669 else:
--> 670 _count_elements(self, iterable)
671 if kwds:
672 self.update(kwds)

TypeError: unhashable type: 'numpy.ndarray'

In [93]: a = np.array([20,30,40,30,30,90,78,5,5,5,10,10,10])

In [94]: st.mode(a)

Out[94]: 30

In [ ]: