NUMPY ARRAY

1. Write a NumPy program to print the NumPy version in your system.

2. Write a NumPy program to convert a list of numeric value into a one-

dimensional NumPy array.
Expected Output:
Original List: [12.23, 13.32, 100, 36.32]
One-dimensional NumPy array: [ 12.23 13.32 100. 36.32]

3.Write a NumPy program to create a 3x3 matrix with values ranging

from 2 to 10.
Expected Output:
[[ 2 3 4]
[ 5 6 7]
[ 8 9 10]]

4. Write a NumPy program to create a null vector of size 10 and update

sixth value to 11.
[ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
Update sixth value to 11
[ 0. 0. 0. 0. 0. 0. 11. 0. 0. 0.]

5. Write a NumPy program to create an array with values ranging from 12

to 38.
Expected Output:
[12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
35 36 37]

6. Write a NumPy program to reverse an array (first element becomes

last).
Original array:
[12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
35 36 37]
Reverse array:
[37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15
14 13 12]

PYTHON 8802551718/9990951718 NumPy Array

 NUMPY ARRAY

7. Write a NumPy program to convert an array to a float type.

Sample output:
Original array
[1, 2, 3, 4]
Array converted to a float type:
[ 1. 2. 3. 4.]

8. Write a NumPy program to create a 2d array with 1 on the border and

0 inside.
Expected Output:
Original array:
[[ 1. 1. 1. 1. 1.]
...................
[ 1. 1. 1. 1. 1.]]
1 on the border and 0 inside in the array
[[ 1. 1. 1. 1. 1.]
...................
[ 1. 1. 1. 1. 1.]]

9. Write a NumPy program to add a border (filled with 0's) around an

existing array.
Expected Output:
Original array:
[[ 1. 1. 1.]
[ 1. 1. 1.]
[ 1. 1. 1.]]
1 on the border and 0 inside in the array
[[ 0. 0. 0. 0. 0.]
...........
[ 0. 0. 0. 0. 0.]]

10. Write a NumPy program to create a 8x8 matrix and fill it with a
checkerboard pattern.
Checkerboard pattern:
[[0 1 0 1 0 1 0 1]
..........
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

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

11. Write a NumPy program to convert a list and tuple into arrays.
List to array:
[1 2 3 4 5 6 7 8]
Tuple to array:
[[8 4 6]
[1 2 3]]

12. Write a NumPy program to append values to the end of an array.

Expected Output:
Original array:
[10, 20, 30]
After append values to the end of the array:
[10 20 30 40 50 60 70 80 90]

13. Write a NumPy program to create an empty and a full array.

Expected Output:
[ 6.93270651e-310 1.59262180e-316 6.93270559e-310 6.93270665e-310]
[ 6.93270667e-310 6.93270671e-310 6.93270668e-310 6.93270483e-310]
[ 6.93270668e-310 6.93270671e-310 6.93270370e-310 6.93270488e-
310]]
[[6 6 6]
[6 6 6]
[6 6 6]]

14. Write a NumPy program to convert the values of Centigrade degrees

into Fahrenheit degrees. Centigrade values are stored into a NumPy
array.
Sample Array [0, 12, 45.21 ,34, 99.91]
Expected Output:
Values in Fahrenheit degrees:
[ 0. 12. 45.21 34. 99.91]
Values in Centigrade degrees:

PYTHON 8802551718/9990951718 NumPy Array

 NUMPY ARRAY

[-17.77777778 -11.11111111 7.33888889 1.11111111 37.72777778]

15. Write a NumPy program to find the real and imaginary parts of an
array of complex numbers.
Expected Output:
Original array [ 1.00000000+0.j 0.70710678+0.70710678j]
Real part of the array:
[ 1. 0.70710678]
Imaginary part of the array:
[ 0. 0.70710678]

16. Write a NumPy program to find the number of elements of an array,

length of one array element in bytes and total bytes consumed by the
elements.
Expected Output:
Size of the array: 3
Length of one array element in bytes: 8
Total bytes consumed by the elements of the array: 24

17. Write a NumPy program to test whether each element of a 1-D array
is also present in a second array.
Expected Output:
Array1: [ 0 10 20 40 60]
Array2: [0, 40]
Compare each element of array1 and array2
[ True False False True False]

18. Write a NumPy program to find common values between two arrays.
Expected Output:
Array1: [ 0 10 20 40 60]
Array2: [10, 30, 40]
Common values between two arrays:
[10 40]

19. Write a NumPy program to get the unique elements of an array.

Expected Output:
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

Original array:
[10 10 20 20 30 30]
Unique elements of the above array:
[10 20 30]
Original array:
[[1 1]
[2 3]]
Unique elements of the above array:
[1 2 3]

20. Write a NumPy program to find the set difference of two arrays. The
set difference will return the sorted, unique values in array1 that are not in
array2.
Expected Output:
Array1: [ 0 10 20 40 60 80]
Array2: [10, 30, 40, 50, 70, 90]
Set difference between two arrays:
[ 0 20 60 80]

21. Write a NumPy program to find the set exclusive-or of two arrays. Set
exclusive-or will return the sorted, unique values that are in only one (not
both) of the input arrays.
Array1: [ 0 10 20 40 60 80]
Array2: [10, 30, 40, 50, 70]
Unique values that are in only one (not both) of the input arrays:
[ 0 20 30 50 60 70 80]

22. Write a NumPy program to find the union of two arrays. Union will
return the unique, sorted array of values that are in either of the two input
arrays.
Array1: [ 0 10 20 40 60 80]
Array2: [10, 30, 40, 50, 70]
Unique sorted array of values that are in either of the two input arrays:
[ 0 10 20 30 40 50 60 70 80]

PYTHON 8802551718/9990951718 NumPy Array

 NUMPY ARRAY

23. Write a NumPy program to test whether all elements in an array

evaluate to True.
Note: 0 evaluates to False in NumPy.

24. Write a NumPy program to test whether any array element along a
given axis evaluates to True.
Note: 0 evaluates to False in NumPy.

25. Write a NumPy program to construct an array by repeating.

Sample array: [1, 2, 3, 4]
Expected Output:
Original array
[1, 2, 3, 4]
Repeating 2 times
[1 2 3 4 1 2 3 4]
Repeating 3 times
[1 2 3 4 1 2 3 4 1 2 3 4]

26. Write a NumPy program to repeat elements of an array.

Expected Output:
[3 3 3 3]
[1 1 2 2 3 3 4 4]

27. Write a NumPy program to find the indices of the maximum and
minimum values along the given axis of an array.
Original array: [1 2 3 4 5 6]
Maximum Values: 5
Minimum Values: 0

28. Write a NumPy program compare two given arrays.

Array a: [1 2]
Array b: [4 5]
a>b
[False False]
a >= b
[False False]
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

a<b
[ True True]
a <= b
[ True True]

29. Write a NumPy program to sort an along the first, last axis of an
array.
Sample array: [[2,5],[4,4]]
Expected Output:
Original array:
[[4 6]
[2 1]]
Sort along the first axis:
[[2 1]
[4 6]]
Sort along the last axis:
[[1 2]
[4 6]]

30. Write a NumPy program to sort pairs of first name and last name
return their indices. (first by last name, then by first name).
first_names = (Betsey, Shelley, Lanell, Genesis, Margery)
last_names = (Battle, Brien, Plotner, Stahl, Woolum)
Expected Output:
[1 3 2 4 0]

31. Write a NumPy program to get the values and indices of the elements
that are bigger than 10 in a given array.
Original array:
[[ 0 10 20]
[20 30 40]]
Values bigger than 10 = [20 20 30 40]
Their indices are (array([0, 1, 1, 1]), array([2, 0, 1, 2]))

32. Write a NumPy program to save a NumPy array to a text file.

PYTHON 8802551718/9990951718 NumPy Array

 NUMPY ARRAY

33. Write a NumPy program to find the memory size of a NumPy array.
Expected Output:
128 bytes

34. Write a NumPy program to create an array of ones and an array of

zeros.
Expected Output:
Create an array of zeros
Default type is float
[[ 0. 0.]]
Type changes to int
[[0 0]]
Create an array of ones
Default type is float
[[ 1. 1.]]
Type changes to int
[[1 1]]

35. Write a NumPy program to change the dimension of an array.

Expected Output:
6 rows and 0 columns
(6,)
(3, 3) -> 3 rows and 3 columns
[[1 2 3]
[4 5 6]
[7 8 9]]
Change array shape to (3, 3) -> 3 rows and 3 columns
[[1 2 3]
[4 5 6]
[7 8 9]]

36. Write a NumPy program to create a contiguous flattened array.

Original array:
[[10 20 30]
[20 40 50]]
New flattened array:
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

[10 20 30 20 40 50]

37. Write a NumPy program to create a 2-dimensional array of size 2 x 3

(composed of 4-byte integer elements), also print the shape, type and data
type of the array.
Expected Output:

(2, 3)
int32

38. Write a NumPy program to create a new shape to an array without

changing its data.
Reshape 3x2:
[[1 2]
[3 4]
[5 6]]
Reshape 2x3:
[[1 2 3]
[4 5 6]]

39. Write a NumPy program to change the data type of an array.

Expected Output:
[[ 2 4 6]
[ 6 8 10]]
Data type of the array x is: int32
New Type: float64
[[ 2. 4. 6.]
[ 6. 8. 10.]]

40. Write a NumPy program to create a new array of 3*5, filled with 2.
Expected Output:
[[2 2 2 2 2]
[2 2 2 2 2]
[2 2 2 2 2]]
[[2 2 2 2 2]
[2 2 2 2 2]
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

[2 2 2 2 2]]

41. Write a NumPy program to create an array of 10's with the same
shape and type of a given array.
Sample array: x = np.arange(4, dtype=np.int64)
Expected Output:
[10 10 10 10]

42. Write a NumPy program to create a 3-D array with ones on a diagonal
and zeros elsewhere.
Expected Output:
[[ 1. 0. 0.]
[ 0. 1. 0.]
[ 0. 0. 1.]]

43. Write a NumPy program to create a 2-D array whose diagonal equals
[4, 5, 6, 8] and 0's elsewhere.
Expected Output:
[[4 0 0 0]
[0 5 0 0]
[0 0 6 0]
[0 0 0 8]]

44. Write a NumPy program to create a 1-D array going from 0 to 50 and
an array from 10 to 50.
Expected Output:
Array from 0 to 50:
[ 0 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 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
48 49]
Array from 10 to 50:
[10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
33 34
35 36 37 38 39 40 41 42 43 44 45 46 47 48 49]

PYTHON 8802551718/9990951718 NumPy Array

 NUMPY ARRAY

45. Write a NumPy program to Create a 1-D array of 30 evenly spaced

elements between 2.5. and 6.5, inclusive.
Expected Output:
[ 2.5 2.63793103 2.77586207 2.9137931 3.05172414 3.18965517
.................
5.81034483 5.94827586 6.0862069 6.22413793 6.36206897 6.5 ]

46. Write a NumPy program to to create a 1-D array of 20 element

spaced evenly on a log scale between 2. and 5., exclusive.
Expected Output:
[ 100. 141.25375446 199.5262315 281.83829313
......................
25118.8643151 35481.33892336 50118.72336273 70794.57843841]

47. Write a NumPy program to create an array which looks like below
array.
Expected Output:
[[ 0. 0. 0.]
...........
[ 1. 1. 1.]]

48. Write a NumPy program to create an array which looks like below
array.
Expected Output:
[[ 2 3 4]
[ 5 6 7]
[ 0 9 10]
[ 0 0 13]]

49. Write a NumPy program to collapse a 3-D array into one dimension
array.
Expected Output:
3-D array:
[[ 1. 0. 0.]
[ 0. 1. 0.]
[ 0. 0. 1.]]
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

One dimension array:

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

50. Write a NumPy program to find the 4th element of a specified array.
Expected Output:
[[ 2 4 6]
[ 6 8 10]]
Forth e1ement of the array:
6

51. Write a NumPy program to interchange two axes of an array.

Sample array: [[1 2 3]]
Expected Output:
[[1]
[2]
[3]]

52. Write a NumPy program to move axes of an array to new positions.

Other axes remain in their original order.
Expected Output:
(3, 4, 2)
(4, 2, 3)

53. Write a NumPy program to move the specified axis backwards, until it
lies in a given position.
Move the following 3rd array axes to first position.
(2,3,4,5)
Sample Expected Output:
(2, 5, 3, 4)

54. Write a NumPy program to convert specified inputs to arrays with at

least one dimension.
Expected Output:
[ 12.]
[[ 0. 1. 2.]
[ 3. 4. 5.]]
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

[array([1]), array([3, 4])]

55. Write a NumPy program to view inputs as arrays with at least two
dimensions, three dimensions.
Expected Output:
View inputs as arrays with at least two dimensions:
[10]
[[ 0. 1.]
[ 2. 3.]]
View inputs as arrays with at least three dimensions:
[[[15]]]
[[[ 0.]
[ 1.]
[ 2.]]]

56. Write a NumPy program to insert a new axis within a 2-D array.
2-D array of shape (3, 4).
Expected Output:
New shape will be will be (3, 1, 4).

57. Write a NumPy program to remove single-dimensional entries from a

specified shape.
Specified shape: (3, 1, 4)
Expected Output: (3, 4)

58. Write a NumPy program to concatenate two 2-dimensional arrays.

Expected Output:
Sample arrays: ([[0, 1, 3], [5, 7, 9]], [[0, 2, 4], [6, 8, 10]]
Expected Output:
[[ 0 1 3 0 2 4]
[ 5 7 9 6 8 10]]

59. Write a NumPy program to convert 1-D arrays as columns into a 2-D
array.
Sample array: (10,20,30), (40,50,60)
Expected Output:
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

[[10 40]
[20 50]
[30 60]]

60. Write a NumPy program to convert (in sequence depth wise (along
third axis)) two 1-D arrays into a 2-D array.
Sample array: (10,20,30), (40,50,60)
Expected Output:
[[[10 40]]
[[20 50]]
[[30 60]]]

61. Write a NumPy program to split an array of 14 elements into 3 arrays,

each of which has 2, 4, and 8 elements in the original order.
Expected Output:
Original array: [ 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
After splitting:
[array([1, 2]), array([3, 4, 5, 6]), array([ 7, 8, 9, 10, 11, 12, 13, 14])]

62. Write a NumPy program to split of an array of shape 4x4 it into two
arrays along the second axis.
Sample array :
[[ 0 1 2 3]
........
[12 13 14 15]]
Expected Output:
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]]), array([], shape=(4, 0), dtype=int64)]

63. Write a NumPy program to get the number of nonzero elements in

an array.
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

Expected Output:
Original array:
[[ 0 10 20]
[20 30 40]]
Number of non zero elements in the above array:
5

64. Write a NumPy program to create a 5x5 matrix with row values
ranging from 0 to 4.
Original array:
[[ 0. 0. 0. 0. 0.]
.........
[ 0. 0. 0. 0. 0.]]
Row values ranging from 0 to 4.
[[ 0. 1. 2. 3. 4.]
..........
[ 0. 1. 2. 3. 4.]]

65. Write a NumPy program to test whether specified values are present
in an array.
Expected Output:
Original array:
[[ 1.12 2. 3.45]
[ 2.33 5.12 6. ]]
True
False
True
False
True

66. Write a NumPy program to create a vector of size 10 with values

ranging from 0 to 1, both excluded.
Expected Output:
[ 0.09090909 0.18181818 0.27272727 0.36363636 0.45454545
0.54545455
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

0.63636364 0.72727273 0.81818182 0.90909091]

67. Write a NumPy program to make an array immutable (read-only).

Expected Output:
Test the array is read-only or not:
Try to change the value of the first element:
Traceback (most recent call last):
File "19236bd0-0bd9-11e7-a232-c706d0968eb6.py", line 6, in
x[0] = 1
ValueError: assignment destination is read-only

68. Write a NumPy program (using NumPy) to sum of all the multiples of
3 or 5 below 100.
Expected Output:
[ 3 5 6 9 10 12 15 18 20 21 24 25 27 30 33 35 36 39 40 42 45 48 50 51 54
55 57 60 63 65 66 69 70 72 75 78 80 81 84 85 87 90 93 95 96 99]
2318

69. Write a NumPy program to create an array with 10^3 elements.

Expected Output:
[ 0. 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. 30. 31. 32. 33. 34. 35.
-----------------
972. 973. 974. 975. 976. 977. 978. 979. 980. 981. 982. 983.
984. 985. 986. 987. 988. 989. 990. 991. 992. 993. 994. 995.
996. 997. 998. 999.]

70. Write a NumPy program to create display every element of a NumPy

array.
Expected Output:
0 1 2 3 4 5 6 7 8 9 10 11

71. Write a NumPy program to create and display every element of a

NumPy array in Fortran order.
Expected Output:
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

Elements of the array in Fortan array:

0 4 8 1 5 9 2 6 10 3 7 11

72. Write a NumPy program to create a 5x5x5 cube of 1's.

Expected Output:
[[[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]]]

73. Write a NumPy program to create an array of (3, 4) shape, multiply

every element value by 3 and display the new array.
Expected Output:
Original array elements:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
New array elements:
[[ 0 3 6 9]
[12 15 18 21]
[24 27 30 33]]

74. Write a NumPy program to combine a one and a two dimensional

array together and display their elements.
Expected Output:
One dimensional array:
[0 1 2 3]
Two dimensional array:
[[0 1 2 3]
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

[4 5 6 7]]
0:0
1:1
2:2
3:3
0:4
1:5
2:6
3:7

75. Write a NumPy program to create an array of zeros and three column
types (integer, float, character).
Expected Output:
[(1, 2., b'Albert Einstein') (2, 2., b'Edmond Halley')
(3, 3., b'Gertrude B. Elion')]

76. Write a NumPy program to create a function cube which cubes all the
elements of an array.
Expected Output:
[ 1 8 27]

77. Write a NumPy program to create an array of (3, 4) shape and

convert the array elements in smaller chunks.
Expected Output:
Original array elements:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[0 4 8]
[1 5 9]
[ 2 6 10]
[ 3 7 11]

78. Write a NumPy program to create a record array from a (flat) list of
arrays.
Sample arrays: [1,2,3,4], ['Red', 'Green', 'White', 'Orange'],
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

[12.20,15,20,40]
Expected Output:
(1, 'Red', 12.2)
(2, 'Green', 15.0)
(3, 'White', 20.0)

79. Write a NumPy program to generate a generic 2D Gaussian-like

array.
Expected Output:
2D Gaussian-like array:
[[ 0.36787944 0.44822088 0.51979489 0.57375342 0.60279818
0.60279818
0.57375342 0.51979489 0.44822088 0.36787944]
..........
[ 0.36787944 0.44822088 0.51979489 0.57375342 0.60279818
0.60279818
0.57375342 0.51979489 0.44822088 0.36787944]]

80. Write a NumPy program to convert a NumPy array into Python list
structure.
Expected Output:
Original array elements:
[[0 1]
[2 3]
[4 5]]
Array to list:
[[0, 1], [2, 3], [4, 5]]

81. Write a NumPy program to access an array by column.

Expected Output:
Original array elements:
[[0 1]
[2 3]
[4 5]]
Access an array by column:
First column:
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

[0 1]
Second column:
[2 3]
Third column:
[4 5]

82. Write a NumPy program to convert a NumPy array of float values to a

NumPy array of integer values.
Expected Output:
Original array elements:
[[ 12. 12.51]
[ 2.34 7.98]
[ 25.23 36.5 ]]
Convert float values to intger values:
[[12 12]
[ 2 7]
[25 36]]

83. Write a NumPy program to display NumPy array elements of floating

values with given precision.
Expected Output:
Original array elements:
[ 0.26153123 0.52760141 0.5718299 0.5927067 0.7831874 0.69746349
0.35399976 0.99469633 0.0694458 0.54711478]
Print array values with precision 3:
[ 0.262 0.528 0.572 0.593 0.783 0.697 0.354 0.995 0.069 0.547]

84. Write a NumPy program to suppresses the use of scientific notation

for small numbers in NumPy array.
Expected Output:
Original array elements:
[ 1.60000000e-10 1.60000000e+00 1.20000000e+03 2.35000000e-01]
Print array values with precision 3:
[ 0. 1.6 1200. 0.235]

PYTHON 8802551718/9990951718 NumPy Array

 NUMPY ARRAY

85. Write a NumPy program to create a NumPy array of 10 integers from

a generator.

Expected Output:
[0 1 2 3 4 5 6 7 8 9]

86. Write a NumPy program to add an extra column to a NumPy array.

Expected Output:
[[ 10 20 30 100]
[ 40 50 60 200]]

87. Write a NumPy program to find unique rows in a NumPy array.

Expected Output:
Original array:
[[20 20 20 0]
.......
[10 20 20 20]]
Unique rows of the above array:
[[ 0 20 20 20]
[10 20 20 20]
[20 20 20 0]]

88. Write a NumPy program to replace all elements of NumPy array that
are greater than specified array.

Expected Output:
Original array:
[[ 0.42436315 0.48558583 0.32924763]
[ 0.7439979 0.58220701 0.38213418]
[ 0.5097581 0.34528799 0.1563123 ]]
Replace all elements of the said array with .5 which are greater than. 5
[[ 0.42436315 0.48558583 0.32924763]
[ 0.5 0.5 0.38213418]

PYTHON 8802551718/9990951718 NumPy Array

 NUMPY ARRAY

[ 0.5 0.34528799 0.1563123 ]]

89. Write a NumPy program to remove specific elements in a NumPy

array.

Expected Output:
Original array:
[ 10 20 30 40 50 60 70 80 90 100]
Delete first, fourth and fifth elements:
[ 20 30 60 70 80 90 100]

90. Write a NumPy program to remove the negative values in a NumPy

array with 0.

Expected Output:
Original array:
[-1 -4 0 2 3 4 5 -6]
Replace the negative values of the said array with 0:
[0 0 0 2 3 4 5 0]

91. Write a NumPy program to remove all rows in a NumPy array that
contain non-numeric values.
Expected Output:
Original array:
[[ 1. 2. 3.]
[ 4. 5. nan]
[ 7. 8. 9.]
[ 1. 0. 1.]]
Remove all non-numeric elements of the said array
[[ 1. 2. 3.]
[ 7. 8. 9.]
[ 1. 0. 1.]]

92. Write a NumPy program to select indices satisfying multiple

conditions in a NumPy array.
Sample array :
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

a = np.array([97, 101, 105, 111, 117])

b = np.array(['a','e','i','o','u'])
Note: Select the elements from the second array corresponding to
elements in the first array that are greater than 100 and less than 110
Expected Output:
Original arrays
[ 97 101 105 111 117]
['a' 'e' 'i' 'o' 'u']
Elements from the second array corresponding to elements in the first
array that are greater than 100 and less than 110:
['e' 'i']

93. Write a NumPy program to get the magnitude of a vector in NumPy.

Expected Output:
Original array:
[1 2 3 4 5]
Magnitude of the vector:
7.4161984871

94. Write a NumPy program to count the frequency of unique values in

NumPy array.
Expected Output:
Original array:
[10 10 20 10 20 20 20 30 30 50 40 40]
Frequency of unique values of the said array:
[[10 20 30 40 50]
[ 3 4 2 2 1]]

95. Write a NumPy program to check whether the NumPy array is empty
or not.
Expected Output:
2
0

96. Write a NumPy program to divide each row by a vector element.

Expected Output:
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

Original array:
[[20 20 20]
[30 30 30]
[40 40 40]]
Vector:
[20 30 40]
[[ 1. 1. 1.]
[ 1. 1. 1.]
[ 1. 1. 1.]]

97. Write a NumPy program to print all the values of an array.

Expected Output:
[[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]]

98. Write a NumPy program to convert the raw data in an array to a

binary string and then create an array.
Expected Output:
Original array:
[ 10. 20. 30.]
Binary string array:
b'\x00\x00\x00\x00\x00\x00$@\x00\x00\x00\x00\x00\x004@\x00\x00\x00
\x00\x00\x00>@'
Array using fromstring():
[ 10. 20. 30.]

99. Write a NumPy program to sum and compute the product of a

NumPy array elements.
Expected Output:
Original array:
[ 10. 20. 30.]
Sum of the array elements:
60.0
Product of the array elements:
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

6000.0

100. Write a NumPy program to take values from a source array and put
them at specified indices of another array.
Expected Output:
[ 10. 10. 20. 30. 30.]
Put 0 and 40 in first and fifth position of the above array
Array x after put two values: [ 0. 10. 20. 30. 40.]

101. Write a NumPy program to print the full NumPy array, without
truncation.
Truncated output:
[ 0 1 2 ... 1997 1998 1999]

102. Write a NumPy program to convert a NumPy array into a csv file.

103. Write a NumPy program to calculate the Euclidean distance.

From Wikipedia:
In mathematics, the Euclidean distance or Euclidean metric is the
"ordinary" straight-line distance between two points in Euclidean space.
With this distance, Euclidean space becomes a metric space. The
associated norm is called the Euclidean norm. Older literature refers to
the metric as the Pythagorean metric.
Sample Output:
Euclidean distance: 5.196152422706632

104. Write a NumPy program to access last two columns of a

multidimensional columns.
Sample Output:
[[1 2 3]
[4 5 6]
[7 8 9]]
[[2 3]
[5 6]

PYTHON 8802551718/9990951718 NumPy Array

 NUMPY ARRAY

[8 9]]

105. Write a NumPy program to read a CSV data file and store records in
an array.
Sample CSV file: fdata.csv
Date,Open,High,Low,Close
03-10-16,774.25,776.065002,769.5,772.559998
.................
07-10-16,779.659973,779.659973,770.75,775.080017
Sample Output:
[(b'Date', nan, nan, nan, nan)
(b'03-10-16', 774.25, 776.065, 769.5 , 772.56)
......................
(b'07-10-16', 779.66, 779.66 , 770.75, 775.08)]

106. Write a NumPy program to count the occurrence of a specified item

in a given NumPy array.
Sample Output:
Original array:
[10 20 20 20 20 0 20 30 30 30 0 0 20 20 0]
1
7
3
4

107. Write a NumPy program to calculate percentiles for a sequence or

single-dimensional NumPy array.
Sample Output:
50th percentile (median):
3.0
40th percentile:
2.6
90th percentile:
4.6

PYTHON 8802551718/9990951718 NumPy Array

 NUMPY ARRAY

108. Write a NumPy program to convert a PIL Image into a NumPy

array.
Sample Output:
[[[255 255 255 0]
.......
[255 255 255 0]]]

109. Write a NumPy program to convert a NumPy array to an image.

Display the image.
Sample Output:

110. Write a NumPy program to remove nan values from a given array.
Sample Output:
Original array:
[200. 300. nan nan nan 700.]
After removing nan values:
[200. 300. 700.]
Original array:
[[ 1. 2. 3.]
[nan 0. nan]
[ 6. 7. nan]]
After removing nan values:
[1. 2. 3. 0. 6. 7.]

111. Write a NumPy program to create a Cartesian product of two arrays

into single array of 2D points.

PYTHON 8802551718/9990951718 NumPy Array

 NUMPY ARRAY

Sample Output:
[[1 4]
......
[3 5]]

112. Write a NumPy program to get the memory usage by NumPy

arrays.
Sample Output:
8256

113. Write a NumPy program to build an array of all combinations of

three NumPy arrays.
Sample Output:
Original arrays:
Array-1
[1, 2, 3]
Array-2
[4, 5]
Array-3
[6, 7]
Combine array:
[[1 4 6]
........
[3 4 7]
[3 5 7]]

114. Write a NumPy program to create random set of rows from 2D

array.
Sample Output:
Random set of rows from 2D array array:
[[4 0 2]
.......
[3 4 3]]

115. Write a NumPy program to find indices of elements equal to zero in

a NumPy array.
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

Sample Output:
Original array:
[1 0 2 0 3 0 4 5 6 7 8]
Indices of elements equal to zero of the said array:
[1 3 5]

116. Write a NumPy program to compute the histogram of a set of data.

Sample Output:

117. Write a NumPy program to compute the line graph of a set of data.
Sample Output:

118. Write a NumPy program to find the position of the index of a

specified value greater than existing value in NumPy array.

PYTHON 8802551718/9990951718 NumPy Array

 NUMPY ARRAY

Sample Output:
Original array:
[-6 -5 -4 -3 -2 -1 0 1 2 3 4 5]
Position of the index:
9

119. Write a NumPy program to add a new row to an empty NumPy

array.
Sample Output:
Empty array:
[]
After adding two new arrays:
[[10 20 30]
[40 50 60]]

120. Write a NumPy program to get the index of a maximum element in

a NumPy array along one axis.
Sample Output:
Original array:
[[1 2 3]
[4 3 1]]
Index of a maximum element in a NumPy array along one axis:
4

121. Write a NumPy program to join a sequence of arrays along a new

axis.
Sample Output:
Original arrays:
[1 2 3]
[2 3 4]
Sequence of arrays along a new axis:
[[1 2 3]
[2 3 4]]
Original arrays:
[[1]
[2]
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

[3]]
[[2]
[3]
[4]]
Sequence of arrays along a new axis:
[[1]
[2]
[3]
[2]
[3]
[4]]

122. Write a NumPy program to find the index of the sliced elements as
follows from a given 4x4 array.
Sample Output:
Original arrays:
[[ 0 1 2 3]
........
[12 13 14 15]]
Sliced elements:
[ 0 5 11]

123. Write a NumPy program to create two arrays of size bigger and
smaller than a given array.
Sample Output:
Original arrays:
[[ 0 1 2 3]
........
[12 13 14 15]]
Array with size 2x2 from the said array:
[[0 1]
[2 3]]
Array with size 6x6 from the said array:
[[ 0 1 2 3 4 5]
.........

PYTHON 8802551718/9990951718 NumPy Array

 NUMPY ARRAY

[14 15 0 1 2 3]]

124. Write a NumPy program to broadcast on different shapes of arrays

where p(3,3) + q(3).
Sample Output:
Original arrays:
Array-1
[[0 0 0]
[1 2 3]
[4 5 6]]
Array-2
[10 11 12]
New Array:
[[10 11 12]
[11 13 15]
[14 16 18]]

125. Write a NumPy program to broadcast on different shapes of arrays

where a(,3) + b(3).
Sample Output:
Original arrays:
Array-1
[[ 0]
[10]
[20]]
Array-2
[10 11 12]
New Array:
[[10 11 12]
[20 21 22]
[30 31 32]]

126. Write a NumPy program to rearrange the dimensions of a given

array.
Sample Output:
Original arrays:
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

[[ 0 1 2 3]
...........
[20 21 22 23]]
After reverse the dimensions:
[[ 0 4 8 12 16 20]
............
[ 3 7 11 15 19 23]]

127. Write a NumPy program to stack arrays in sequence horizontally

(column wise).
Sample Output:
Original arrays:
Array-1
[[0 1 2]
[3 4 5]
[6 7 8]]
Array-2
[[ 0 3 6]
[ 9 12 15]
[18 21 24]]
Stack arrays in sequence horizontally:
[[ 0 1 2 0 3 6]
[ 3 4 5 9 12 15]
[ 6 7 8 18 21 24]]

128. Write a NumPy program to stack arrays in sequence vertically.

Sample Output:
Original arrays:
Array-1
[[0 1 2]
[3 4 5]
[6 7 8]]
Array-2
[[ 0 3 6]
[ 9 12 15]
[18 21 24]]
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

Stack arrays in sequence vertically:

[[ 0 1 2]
...........
[18 21 24]]

129. Write a NumPy program to stack 1-D arrays as columns wise.

Sample Output:
Original arrays:
Array-1
[1 2 3]
Array-2
[2 3 4]
Stack 1-D arrays as columns wise:
[[1 2]
[2 3]
[3 4]]

130. Write a NumPy program to stack 1-D arrays as row wise.

Sample Output:
Original arrays:
Array-1
[1 2 3]
Array-2
[2 3 4]
Stack 1-D arrays as rows wise:
[[1 2 3]
[2 3 4]]

131. Write a NumPy program to split a given array into multiple sub-
arrays vertically (row-wise).
Sample Output:
Original arrays:
[[ 0. 1. 2. 3.]
.............
[12. 13. 14. 15.]]
Split an array into multiple sub-arrays vertically:
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

[array([[0., 1., 2., 3.],

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

132. Write a NumPy program to split array into multiple sub-arrays along
the 3rd axis.
Sample Output:
Original arrays:
[[[ 0. 1. 2. 3.]
[ 4. 5. 6. 7.]]
[[ 8. 9. 10. 11.]
[12. 13. 14. 15.]]]
split array into multiple sub-arrays along the 3rd axis:
[array([[[ 0., 1.],
[ 4., 5.]],
[[ 8., 9.],
[12., 13.]]]), array([[[ 2., 3.],
[ 6., 7.]],
[[10., 11.],
[14., 15.]]])]

133. Write a NumPy program to count the number of dimensions,

number of elements and number of bytes for each element in a given
array.
Sample Output:
Original arrays:
[[ 0 1 2 3 4 5 6 7 8 9 10 11]
[12 13 14 15 16 17 18 19 20 21 22 23]]
Number of dimensions:
2
Number of elements:
24
Number of bytes for each element in the said array:
8

PYTHON 8802551718/9990951718 NumPy Array

 NUMPY ARRAY

134. Write a NumPy program to extract all the elements of the first row
from a given (4x4) array.
Sample Output:
Original array:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
Extracted data: First row
[0 1 2 3]

135. Write a NumPy program to extract all the elements of the second
row from a given (4x4) array.
Sample Output:
Original array:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
Extracted data: Second row
[4 5 6 7]

136. Write a NumPy program to extract all the elements of the third
column from a given (4x4) array.
Sample Output:
Original array:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
Extracted data: Third column
[ 2 6 10 14]

137. Write a NumPy program to extract first and second elements of the
first and second rows from a given (4x4) array.
Sample Output:
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

Original array:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
Extracted data: First and second elements of the first and second rows
[[0 1]
[4 5]]

138. Write a NumPy program to extract third and fourth elements of the
first and second rows from a given (4x4) array.
Sample Output:
Original array:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
Extracted data: Third and fourth elements of the first and second rows
[[2 3]
[6 7]]

139. Write a NumPy program to extract first and third elements of the
first and third rows from a given (4x4) array.
Sample Output:
Original array:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
Extracted data: First and third elements of the first and third rows
[[ 0 2]
[ 8 10]]

140. Write a NumPy program to extract second and fourth elements of

the second and fourth rows from a given (4x4) array.
Sample Output:
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

Original array:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
Extracted data: Second and fourth elements of the second and fourth
rows
[[ 5 7]
[13 15]]

141. Write a NumPy program to extract all the elements of the second
and third columns from a given (4x4) array.
Sample Output:
Original array:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
Extracted data: All the elements of the second and third columns
[[ 1 2]
[ 5 6]
[ 9 10]
[13 14]]

142. Write a NumPy program to extract all the elements of the first and
fourth columns from a given (4x4) array.
Sample Output:
Original array:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
Extracted data: All the elements of the first and fourth columns
[[ 0 3]
[ 4 7]
[ 8 11]
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

[12 15]]

143. Write a NumPy program to extract first element of the second row
and fourth element of fourth row from a given (4x4) array.
Sample Output:
Original array:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
Extracted data: First element of the second row and fourth element of
fourth row
[ 4 15]

144. Write a NumPy program to extract all the elements of the second
and third columns from a given (4x4) array.
Sample Output:
Original array:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
Extracted data: Second and third elements of the second and third rows
[[ 5 6]
[ 9 10]]

145. Write a NumPy program to extract first, third and fifth elements of
the third and fifth rows from a given (6x6) array.
Sample Output:
Original array:
[[ 0 1 2 3 4 5]
................
[30 31 32 33 34 35]]
Extracted data: First, third and fifth elements of the third and fifth rows
[[12 14 16]

PYTHON 8802551718/9990951718 NumPy Array

 NUMPY ARRAY

[24 26 28]]

146. Write a NumPy program to add two arrays A and B of sizes (3,3)
and (,3).
Sample Output:
Original array:
Array-1
[[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]]
Array-2
[0 1 2]
A + B:
[[1. 2. 3.]
[1. 2. 3.]
[1. 2. 3.]]

147. Write a NumPy program to create an array that represents the rank
of each item of a given array.
Sample Output:
Original array:
[24 27 30 29 18 14]
Rank of each item of the said array:
[2 3 5 4 1 0]

148. Write a NumPy program to copy data from a given array to another
array.
Sample Output:
Original array:
[24 27 30 29 18 14]
Copy of the said array:
[24 27 30 29 18 14]

149. Write a NumPy program to find elements within range from a given
array of numbers.
Sample Output:
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

Original array:
[ 1 3 7 9 10 13 14 17 29]
Elements within range: index position
(array([2, 3, 4, 5, 6, 7]),)

150. Write a NumPy program to swap columns in a given array.

Sample Output:
Original array:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
After swapping arrays:
[[ 1 0 2 3]
[ 5 4 6 7]
[ 9 8 10 11]]

151. Write a NumPy program to get the row numbers in given array
where at least one item is larger than a specified value.
Sample Output:
Original array:
[[ 0 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 30 31 32 33 34 35]]
Row numbers where at least one item is larger than 10:
(array([1, 2, 3]),)

152. Write a NumPy program to calculate the sum of all columns of a 2D

NumPy array.
Sample Output:
Original array:
[[ 0 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 30 31 32 33 34 35]]
Sum of all columns:
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

[54 58 62 66 70 74 78 82 86]

153. Write a NumPy program to extract upper triangular part of a

NumPy matrix.
Sample Output:
Original array:
[[ 0 1 2]
...........
[15 16 17]]
Extract upper triangular part of the said array:
[0 1 2 4 5 8]
Extract upper triangular part of the said array:
[0 1 4]

154. Write a NumPy program to get a copy of a matrix with the elements
below the k-th diagonal zeroed.
Sample Output:
Original array:
[[1 2 3]
[0 5 6]
[0 0 9]
[0 0 0]]
Copy of a matrix with the elements below the k-th diagonal zeroed:
[[1 2 3]
[0 5 6]
[0 0 9]
[0 0 0]]

155. Write a NumPy program to check whether a Numpy array contains

a specified row.
Sample Output:
Original array:
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

True
False
True

156. Write a NumPy program to calculate averages without NaNs along a

given array.
Sample Output:
Original array:
[[10. 20. 30.]
[40. 50. nan]
[nan 6. nan]
[nan nan nan]]
Averages without NaNs along the said array:
[20. 45. 6. nan]

157. Write a NumPy program to create a new array which is the average
of every consecutive triplet of elements of a given array.
Sample Output:
Original array:
[ 1 2 3 2 4 6 1 2 12 0 -12 6]
Average of every consecutive triplet of elements of the said array:
[ 2. 4. 5. -2.]

158. Write a NumPy program to calculate average values of two given

NumPy arrays.
Sample Output:
Original arrays:
[[0, 1], [2, 3]]
[[4, 5], [0, 3]]
Average values of two said NumPy arrays:
[[2. 3.]
[1. 3.]]

159. Write a NumPy program to rearrange columns of a given NumPy

2D array using given index positions.
Sample Output:
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

Original arrays:
[[ 11 22 33 44 55]
[ 66 77 88 99 100]]
New array:
[[ 22 44 11 55 33]
[ 77 99 66 100 88]]

160. Write a NumPy program to find the k smallest values of a given

NumPy array.
Sample Output:
Original arrays:
[ 1. 7. 8. 2. 0.1 3. 15. 2.5]
k smallest values:
[0.1 1. 2. 2.5]

161. Write a NumPy program to create a white image of size 512x256.

Sample Output:

162. Create an array (a) of shape 3, 4, 8 (K=3, J=4, I=8). tidx is an array of
the same length as a.shape[1], i.e. contains J = 4 elements where each
index denotes which element of K should be chosen.
Write a NumPy program to select from the first axis (K) by the indices
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

tidx to get an array of shape (J=4, I=8) back.

Sample Output:
Original array and shape:
[[[3 2 2 7 7 7 0 3]
[5 8 4 2 9 9 3 9]
[6 8 2 8 5 7 8 7]
[5 2 4 0 4 9 2 5]]
------------------
tidex: [0 2 2 2]
Result:
[[3 2 2 7 7 7 0 3]
[3 9 2 6 3 3 1 0]
[5 4 0 6 0 2 7 8]
[6 3 1 8 8 1 5 7]]

163. Create two arrays of six elements. Write a NumPy program to count
the number of instances of a value occurring in one array on the condition
of another array.
Sample Output:
Original arrays:
[ 10 -10 10 -10 -10 10]
[0.85 0.45 0.9 0.8 0.12 0.6 ]
Number of instances of a value occurring in one array on the condition of
another array:
3

164. Write a NumPy program to save as text a matrix which has in each
row 2 float and 1 string at the end.
Sample Output:
string
1 0 aaa
0 1 bbb
0 1 ccc

PYTHON 8802551718/9990951718 NumPy Array

 NUMPY ARRAY

165. Write a NumPy program to merge three given NumPy arrays of

same shape.

166. Write a NumPy program to combine last element with first element
of two given ndarray with different shapes.
Original arrays:
['PHP', 'JS', 'C++']
['Python', 'C#', 'NumPy']
After Combining:
['PHP' 'JS' 'C++Python' 'C#' 'NumPy']

167. Write a NumPy program to convert a Python dictionary to a NumPy

ndarray.
Original dictionary:
{'column0': {'a': 1, 'b': 0.0, 'c': 0.0, 'd': 2.0},
'column1': {'a': 3.0, 'b': 1, 'c': 0.0, 'd': -1.0},
'column2': {'a': 4, 'b': 1, 'c': 5.0, 'd': -1.0},
'column3': {'a': 3.0, 'b': -1.0, 'c': -1.0, 'd': -1.0}}
Type: <class 'dict'>
ndarray:
[[ 1. 0. 0. 2.]
[ 3. 1. 0. -1.]
[ 4. 1. 5. -1.]
[ 3. -1. -1. -1.]]
Type: <class 'numpy.ndarray'>

168. Write a NumPy program to convert Pandas dataframe to NumPy

array with headers.
Original NumPy array:
[[0.18308157 0.32258608 0.39644848]
[0.31018507 0.08220454 0.40018982]
[0.63639779 0.34908174 0.39878868]
............
[0.02482073 0.02318678 0.36032194]
[0.69001834 0.04285817 0.31768865]]
Type: <class 'numpy.ndarray'>
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

Panda's DataFrame:
ABC
0 0.015583 0.968431 0.943192
1 0.221607 0.704098 0.241200
2 0.466129 0.269226 0.450781
3 0.747222 0.674508 0.686070
............
10 0.272827 0.817238 0.093650
11 0.196416 0.643602 0.262683
Type: <class 'pandas.core.frame.DataFrame'>

169. Write a NumPy program to get all 2D diagonals of a 3D NumPy

array.
Original NumPy array:
[[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
............
[[40 41 42 43 44]
[45 46 47 48 49]
[50 51 52 53 54]
[55 56 57 58 59]]]
Type: <class 'numpy.ndarray'>
2D diagonals:
[[ 0 6 12 18]
[20 26 32 38]
[40 46 52 58]]
Type: <class 'numpy.ndarray'>

170. Create a 2-dimensional array of size 2 x 3, composed of 4-byte

integer elements. Write a NumPy program to find the number of
occurrences of a sequence in the said array.
Original NumPy array:
[[1 2 3]
[2 1 2]]
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

Type: <class 'numpy.ndarray'>

Sequence: 2,3
Number of occurrences of the said sequence: 2

171. Write a NumPy program to search the index of a given array in

another given array.
Original NumPy array:
[[ 1 2 3]
[ 4 5 6]
[ 7 8 9]
[10 11 12]]
Searched array:
[4 5 6]
Index of the searched array in the original array:
[1]

172. Write a NumPy program to find and store non-zero unique rows in
an array after comparing each row with other row in a given matrix.
Original array:
[[ 1 1 0]
[ 0 0 0]
[ 0 2 3]
[ 0 0 0]
[ 0 -1 1]
[ 0 0 0]]
Non-zero unique rows:
[[ 1 1 0]
[ 0 2 3]
[ 0 -1 1]]

173. Write a NumPy program to set zero to lower triangles along the last
two axes of a three-dimensional of a given array.
Original array:
[[[1. 1. 1. 1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1. 1. 1. 1.]
..............
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

[1. 1. 1. 1. 1. 1. 1. 1.]]]
Result:
[[[0. 1. 1. 1. 1. 1. 1. 1.]
[0. 0. 1. 1. 1. 1. 1. 1.]
.................
[0. 0. 0. 0. 0. 0. 0. 0.]]]

174. Write a NumPy program to get the number of items, array

dimensions, number of array dimensions and the memory size of each
element of a given array.
Original array:
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
Number of items of the said array:
12
Array dimensions:
(3, 4)
Number of array dimensions:
2
Memory size of each element of the said array
8

175. Write a NumPy program to create an 1-D array of 20 elements. Now

create a new array of shape (5, 4) from the said array, then restores the
reshaped array into a 1-D array.
Original array:
[ 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38]
New array of shape(5, 3):
[[ 0 2 4 6]
[ 8 10 12 14]
[16 18 20 22]
[24 26 28 30]
[32 34 36 38]]
Restore the reshaped array into a 1-D array:

PYTHON 8802551718/9990951718 NumPy Array

 NUMPY ARRAY

[ 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38]

176. Write a NumPy program to create an array of 4,5 shape and swap
column1 with column4.
Original array:
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
After swapping column1 with column4:
[[ 3 1 2 0 4]
[ 8 6 7 5 9]
[13 11 12 10 14]
[18 16 17 15 19]]

177. Write a NumPy program to create an array of 4,5 shape and to

reverse the rows of the said array. After reversing 1st row will be 4th and
4th will be 1st, 2nd row will be 3rd row and 3rd row will be 2nd row.
Original array:
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
After reversing:
[[15 16 17 18 19]
[10 11 12 13 14]
[ 5 6 7 8 9]
[ 0 1 2 3 4]]

178. Write a NumPy program to replace all the nan (missing values) of a
given array with the mean of another array.
Original arrays:
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

[[ 1. 2. nan]
[ 4. 5. 6.]
[nan 7. nan]]
All the nan of array_nums2 replaced by the mean of array_nums1:
[[1. 2. 9.5]
[4. 5. 6. ]
[9.5 7. 9.5]]

179. Write a NumPy program to fetch all items from a given array of 4,5
shape which are either greater than 6 and a multiple of 3.
Original arrays:
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
Items greater than 6 and a multiple of 3 of the said array:
[ 9 12 15 18]

180. Write a NumPy program to check whether the dimensions of two

given arrays are same or not.

181. Write a NumPy program to place a specified element in specified

time randomly in a specified 2D array.
Original array:
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
Place a specified element in specified time randomly:
[[10. 0. 0. 0.]
[10. 0. 0. 0.]
[ 0. 0. 0. 10.]
[ 0. 0. 0. 0.]]

182. Write a NumPy program to subtract the mean of each row of a given
matrix.
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

Original matrix:
[[0.59243452 0.51883289 0.03732848 0.49544926 0.22637201
0.45750412
0.81614237 0.86681236 0.95482226 0.54789281]
..............
[0.14428353 0.20556412 0.97059136 0.53545871 0.93828877
0.81535277
0.60563373 0.47543413 0.0468766 0.97460889]]
Subtract the mean of each row of the said matrix:
[[ 0.04107541 -0.03252622 -0.51403063 -0.05590985 -0.3249871 -
0.09385499
0.26478326 0.31545325 0.40346315 -0.0034663 ]
....................
[-0.42692573 -0.36564514 0.3993821 -0.03575056 0.36707951
0.24414351
0.03442447 -0.09577513 -0.52433266 0.40339963]]

183. Write a NumPy program to test whether a given 2D array has null
columns or not.
Original array:
[[1 2 1 1 1 2 1 1 2 0]
[1 1 0 0 0 0 2 1 2 0]
[0 0 2 1 0 2 2 2 2 2]
[1 1 1 2 0 0 0 0 1 2]]
Test whether the said array has null columns or not:
False

184. Write a NumPy program to create an array using generator function

that generates 15 integers.
New array:
[ 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14.]

185. Write a NumPy program to create a new vector with 2 consecutive 0

between two values of a given vector.
Original array:
[1 2 3 4 5 6 7 8]
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

New array:
[1. 0. 0. 2. 0. 0. 3. 0. 0. 4. 0. 0. 5. 0. 0. 6. 0. 0. 7. 0. 0. 8.]

186. Write a NumPy program to create a new vector with 2 consecutive 0

between two values of a given vector.
Original array:
[[[1. 1. 1.]
[1. 1. 1.]]
[[1. 1. 1.]
[1. 1. 1.]]]
New array:
[[[3. 3. 3.]
[3. 3. 3.]]
[[3. 3. 3.]
[3. 3. 3.]]]

187. Write a NumPy program to convert a given vector of integers to a

matrix of binary representation.
Original vector:
[ 0 1 3 5 7 9 11 13 15]
Binary representation of the said vector:
[[0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 1]
..............
[0 0 0 0 1 1 1 1]]

188. Write a NumPy program to extract rows with unequal values (e.g.
[1,1,2]) from 10x3 matrix.
Original vector:
[[3 2 0]
........
[3 0 2]]
Rows with unequal values:
[[3 2 0]
[2 3 1]
.........
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

[3 0 2]]

189. Write a NumPy program to find rows of a given array of shape (8,3)
that contain elements of each row of another given array of shape (2,2).
Original arrays:
[[5 2 5 1]
[5 4 1 3]
..........
[4 0 4 0]]
[[2 3 1]
[1 1 4]]
Rows of a given array that contain elements of each row of another given
array:
[0 1 2 4]

190. Write a NumPy program to create a record array from a given

regular arrar.
Original arrays:
[['Yasemin Rayner' '88.5' '90']
['Ayaana Mcnamara' '87' '99']
['Jody Preece' '85.5' '91']]
Record array;
[(b'Yasemin Rayner', 88.5, 90) (b'Ayaana Mcnamara', 87. , 99)
(b'Jody Preece', 85.5, 91)]

191. Write a NumPy program to get the block-sum (block size is 5x5)
from a given array of shape 25x25.
Original arrays:
[[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.]]
Block-sum (5x5) of the said array:
[[25. 25. 25. 25. 25.]
[25. 25. 25. 25. 25.]
[25. 25. 25. 25. 25.]
PYTHON 8802551718/9990951718 NumPy Array
 NUMPY ARRAY

[25. 25. 25. 25. 25.]

[25. 25. 25. 25. 25.]]

192. Write a NumPy program to extract all the contiguous 4x4 blocks
from a given random 12x12 matrix.
Original arrays:
[[3 3 1 2 0 3 0 3 2 0 1 0]
[4 0 4 2 0 0 0 0 2 2 2 3]
..................
[1 2 3 4 1 2 3 4 3 2 3 4]
[4 0 4 2 2 4 1 4 2 0 0 0]]
Contiguous 4x4 blocks:
[[[[3 3 1 2]
[4 0 4 2]
[1 4 0 1]
[1 4 2 4]]
...
[[4 1 1 0]
[1 0 2 2]
[3 2 3 4]
[2 0 0 0]]]]

PYTHON 8802551718/9990951718 NumPy Array