NumPy - Basics - Practice Problems

[akash-coded]

1. Write a NumPy program to test whether none of the elements of a given array is zero.

2. Write a NumPy program to test whether any of the elements of a given array is non-zero.

3. Write a NumPy program to test a given array element-wise for finiteness (not infinity or not a Number).

4. Write a NumPy program to test element-wise for positive or negative infinity.

5. Write a NumPy program to test element-wise for NaN of a given array.

6. Write a NumPy program to test element-wise for complex number, real number of a given array. Also test whether a given number is a scalar type or not.

7. Write a NumPy program to test whether two arrays are element-wise equal within a tolerance.

8. Write a NumPy program to create an element-wise comparison (greater, greater_equal, less and less_equal) of two given arrays.

9. Write a NumPy program to create an element-wise comparison (equal, equal within a tolerance) of two given arrays.

10. Write a NumPy program to create an array with the values 1, 7, 13, 105 and determine the size of the memory occupied by the array.

11. Write a NumPy program to create an array of 10 zeros,10 ones, 10 fives.

12. Write a NumPy program to create an array of the integers from 30 to70.

13. Write a NumPy program to create an array of all the even integers from 30 to 70.

14. Write a NumPy program to create a 3x3 identity matrix.

15. Write a NumPy program to generate a random number between 0 and 1.

16. Write a NumPy program to generate an array of 15 random numbers from a standard normal distribution.

17. Write a NumPy program to find the number of rows and columns of a given matrix.

18. Write a NumPy program to create a 3x3 identity matrix, i.e. diagonal elements are 1, the rest are 0.

19. Write a NumPy program to create a 10x10 matrix, in which the elements on the borders will be equal to 1, and inside 0.

20. Write a NumPy program to create a 5x5 zero matrix with elements on the main diagonal equal to 1, 2, 3, 4, 5.

21. Write a NumPy program to compute sum of all elements, sum of each column and sum of each row of a given array.

22. Write a NumPy program to create a 4x4 array, now create a new array from the said array swapping first and last, second and third columns.

23. Write a NumPy program to create a 4x4 array, now create a new array from the said array swapping first and last, second and third columns.

[ElijahHorowitz]

import numpy as np
n = np.array([1, 2, 3, 45])
print(not np.isin(0, n))

import numpy as np
n = np.array([0, 0, 0, 0])
print(np.any(n))

import numpy as np

def checkArray(n):
    for i in range(len(n)):
        if np.isinf(n[i]) or np.isnan(n[i]):
            return True
        elif i == len(n)-1:
            return False
n = np.array([1, 2, 1, 0])
print(checkArray(n))

import numpy as np

def checkArray(n):
    if np.any(np.isposinf(n)) and np.any(np.isneginf(n)):
        print("Positive and Negative")
    elif np.any(np.isposinf(n)):
        print("Positive inf")
    elif np.any(np.isneginf(n)):
        print("Negative inf")
    else:
        print("None are infinity")
        
n = np.array([1, -np.inf, np.inf, 0])
print(checkArray(n))

import numpy as np

def checkArray(n):
    if np.any(np.isnan(n)):
        return True
    else:
        return False
        
n = np.array([1, -np.inf, np.nan, 0])
print(checkArray(n))

import numpy as np

n = np.array([1+1j, 1+0j, 4.5, 3, 2, 2j])
print(np.iscomplex(n))
print(np.isreal(n))
print(np.isscalar([3.1]))

import numpy as np

n = np.array([[2,2,2],[2,2,2]])
p = np.array([[3,1,2],[1,3,2]])
print(np.array_equal(n, p, equal_nan=True))

import numpy as np

n = np.array([[2,2,2],[2,2,2]])
p = np.array([[3,1,2],[1,3,2]])
print("Greater")
print(np.greater(n,p))
print("\ngreater equal")
print(np.greater_equal(n,p))
print("\n less")
print(np.less(n,p))
print("\n less equal")
print(np.less_equal(n,p))

import numpy as np

n = np.array([[2,2,2],[2,2,2]])
p = np.array([[3,1,2],[1,3,2]])
print(np.array_equal(n, p, equal_nan=True))

import numpy as np

n = np.array([1,7,13,105])
print(n.itemsize * np.size(n))

import numpy as np

zero = np.zeros(10)
print(f"{zero} \n")
one = np.ones(10)
print(f"{one}\n")
ten = np.ones(10)*10
print(f"{ten}\n")

import numpy as np

arr = np.arange(30, 70)
print(arr)

import numpy as np

arr = np.arange(30, 70,2)
print(arr)

import numpy as np

arr = np.identity(3)
print(arr)

import numpy as np
num = np.random.uniform(0,1)
print(num)

import numpy as np
num = np.random.normal(0,1,15)
print(num)

import numpy as np
num = np.random.normal(0,1,15)
print(num.shape)

import numpy as np

arr = np.identity(3)
print(arr)

import numpy as np
arr = np.ones((10,10))*10
arr[1:-1, 1:-1] = 0
print(arr)

import numpy as np
arr = np.zeros((5, 5))
for i in range(len(arr)):
    arr[i][i] = i+1
print(arr)

import numpy as np
arr = np.array([[1, 3, 4], [1, 2, 3]])
print(f"{arr} \n")
print(f"{np.sum(arr, axis=1)} is the sum of each row \n{np.sum(arr, axis=0)} is the sum of each column")

import numpy as np
arr = np.array([[1, 3, 4, 6], [2, 3, 6, 7], [3, 5, 8, 9], [5, 4, 0, 1]])
print(f"Original array\n {arr}\n")
arr[:, [3, 0]] = arr[:, [0, 3]]
arr[:, [1, 2]] = arr[:, [2, 1]]
print(f"New array\n {arr}")

[OlvarM]

1. WAP NumPy no zeros in array

# check for zeros in array
import numpy as np

def main():
    # test array
    mat = [[1,2,3],[4,5,6],[7,8,9]]
    arr = np.array(mat)

    # input array
    # arr = np.array(list(input("Enter an array to be checked for zeros: ")))

    # check for zeros
    if np.all(arr):
        print("There are no zeros in the array.")
    else:
        print("There are zeros in the array")



# run main
if __name__ == "__main__":
    main()

2. WAP NumPy any zeros in array

# check for zeros in array
import numpy as np

def main():
    # test array
    mat = [[1,2,0],[4,5,6],[7,8,9]]
    arr = np.array(mat)

    # input array
    # arr = np.array(list(input("Enter an array to be checked for zeros: ")))

    # check for zeros
    if np.any(arr==0):
        print("There are zeros in the array.")
    else:
        print("There are no zeros in the array")


# run main
if __name__ == "__main__":
    main()

3. WAP NumPy finite numbers

# check for finite numbers
import numpy as np

def main():
    # test array
    mat = [[1,2,np.Inf],[4,5,6],[7,8,9]]
    arr = np.array(mat)

    # input array
    # arr = np.array(list(input("Enter an array to be checked for finiteness: ")))

    # check for finite
    if np.all(np.isfinite(arr)):
        print("All elements are finite.")
    else:
        print("Some elements are not finite.")


# run main
if __name__ == "__main__":
    main()

4. WAP NumPy positive or negative infinity

# check for positive infinite or negative infinite
import numpy as np

def main():
    # test array
    mat = [[1,2,np.Inf],[-np.Inf,5,6],[7,8,9]]
    arr = np.array(mat)

    # input array
    # arr = np.array(list(input("Enter an array to check infiniteness: ")))

    # check for infinite
    if np.any(np.isposinf(arr)) and np.any(np.isneginf(arr)):
        print("There are elements that are positive infinite and negative infinite.")
    elif np.any(np.isposinf(arr)):
        print("Some elements are positive infinite.")
    elif np.any(np.isneginf(arr)):
        print("Some elements are negative infinite.")
    else:
        print("All elements are finite.")
    
    


# run main
if __name__ == "__main__":
    main()

5. WAP NumPy check NaN in array

# check for NaN values
import numpy as np

def main():
    # test array
    mat = [[1,np.NaN,np.Inf],[-np.Inf,5,6],[7,8,9]]
    arr = np.array(mat)

    # input array
    # arr = np.array(list(input("Enter an array to check NaN values: ")))

    # check for Nan
    if np.any(np.isnan(arr)):
        print("Some elements are NaN.")
    else:
        print("All elements are valid.")
    
    


# run main
if __name__ == "__main__":
    main()

6. WAP NumPy check complex number, real number and if numbers are scalar in array

# check for complex,real and scalar values
import numpy as np

def main():
    # test array
    mat = [[1,np.NaN,np.Inf],[-np.Inf,5,6],[7,8+2j,9]]
    arr = np.array(mat)

    # input array
    # arr = np.array(list(input("Enter an array to check NaN values: ")))

    # check for complex, real or scalar
    if np.any(np.iscomplex(arr)):
        print("Some elements are Complex.")
    else:
        print("There are no Complex elements in the array.")
    
    if np.any(np.isreal(arr)):
        print("Some elements are Real.")
    else:
        print("There are no Real elements in the array.")
    

    if np.any([np.isscalar(el) for element in mat for el in element]):
        print("Some elements are Scalar.")
    else:
        print("There are no Scalar elements in the array.")
    


# run main
if __name__ == "__main__":
    main()

7. Two arrays equal within a tolerance

# equal with tolerance
import numpy as np

def main():
    a = np.array([1,2,3,4,5])
    b = np.array([1.00000001,1.9999999,3,4.0000007,4.9999999])

    print(f"Array 1:{a} \nArray 2:{b}")
    if np.allclose(a,b):
        print(f"The arrays are considered equal.")
    else:
        print("The arrays are not equal")

if __name__ == "__main__":
    main()

8. Greater, greater_equal, Less, less_equal of two arrays

# >, >=, <, <=
import numpy as np

def main():
    a = np.array([1,2,3,4,5])
    b = np.array([1.00000001,1.999999,3,4.0000007,4.999999])

    print(f"Array A:{a} \nArray B:{b}")
    
    print(f"A Greater B: {np.greater(a,b)}")
    print(f"A Greater Equal B: {np.greater_equal(a,b)}")
    print(F"A Less B: {np.less(a,b)}")
    print(F"A Less Equal B: {np.less_equal(a,b)}")

if __name__ == "__main__":
    main()

9. Equal, Equal within a tolerance of two arrays

# equal
import numpy as np

def main():
    a = np.array([1,2,3,4,5])
    b = np.array([1.00000001,1.999999,3,4.0000007,4.999999])

    print(f"Array A:{a} \nArray B:{b}")
    
    print(f"A equal B: {np.equal(a,b)}")
    print(f"A equal with tolerance B: {np.isclose(a,b)}")


if __name__ == "__main__":
    main()

10. Size and memory of array

# memory and size
import numpy as np

def main():
    a = np.array([[1,2,3,4,5],[3,4j,10,np.inf,-10]])

    print(f"Array A:{a}")
    
    print(f"Size of array A: {np.size(a)}")
    print(f"Memory of array A: {a.nbytes}")


if __name__ == "__main__":
    main()

11. Fixed value arrays

# zeros, ones, full
import numpy as np

def main():
    # a = np.array([[1,2,3,4,5],[3,4j,10,np.inf,-10]])
    # print(f"Array A:{a}")
    
    print(f"10 zeros: {np.zeros(10)}")
    print(f"10 ones: {np.ones(10)}")
    print(f"10 fives : {np.full(10,5)}")


if __name__ == "__main__":
    main()

12. Array in range

# aRange
import numpy as np

def main():
    # a = np.array([[1,2,3,4,5],[3,4j,10,np.inf,-10]])
    # print(f"Array A:{a}")
    
    print(f"Integers from 30 to 70: {np.arange(30,70+1)}")


if __name__ == "__main__":
    main()

13. Array of all even integers in range

# array in range with condition
import numpy as np

def main():
    # a = np.array([[1,2,3,4,5],[3,4j,10,np.inf,-10]])
    # print(f"Array A:{a}")
    
    print(f"Even Integers from 30 to 70: {np.arange(30,70+1,step=2)}")


if __name__ == "__main__":
    main()

14. 3x3 identity matrix

# identity matrix
import numpy as np

def main():
    # a = np.array([[1,2,3,4,5],[3,4j,10,np.inf,-10]])
    # print(f"Array A:{a}")
    
    print(f"Identity Matrix 3x3: \n{np.identity(3)}")


if __name__ == "__main__":
    main()

15. NumPy random number

# random
import numpy as np

def main():
    # a = np.array([[1,2,3,4,5],[3,4j,10,np.inf,-10]])
    # print(f"Array A:{a}")
    
    print(f"Random Number (0,1): \n{np.random.rand()}")


if __name__ == "__main__":
    main()

16. Array of 15 random numbers (standard normal distribution)

# rand with dist
import numpy as np

def main():
    # a = np.array([[1,2,3,4,5],[3,4j,10,np.inf,-10]])
    # print(f"Array A:{a}")
    
    print(f"15 Random Number with standard normal distribution: \n{np.random.randn(15,)}")


if __name__ == "__main__":
    main()

17. Find number of rows and columns in a matrix

# row and column size (shape)
import numpy as np

def main():
    a = np.array([[1,2,3,4,5],[3,4j,10,np.inf,-10]])
    print(f"Array A:{a}")
    
    print(f"Array A Row and Column Size: \n{np.shape(a)}")


if __name__ == "__main__":
    main()

18. Identity Matrix

# nxn identity matrix
import numpy as np

def main():
    # a = np.array([[1,2,3,4,5],[3,4j,10,np.inf,-10]])
    # print(f"Array A:{a}")
    n = int(input("Identity Matrix size: "))
    print(f"Array A Row and Column Size {n}: \n{np.identity(n)}")


if __name__ == "__main__":
    main()

19. 10x10 matrix with borders = 1

# 10x10 matrix with borders
import numpy as np

def main():
    # a = np.array([[1,2,3,4,5],[3,4j,10,np.inf,-10]])
    # print(f"Array A:{a}")
    
    # 10x10 matrix
    mat = np.ones((10,10))
    #put zeros in the center
    mat[1:-1,1:-1] = 0

    print(f"10x10 matrix with border: \n{mat}")


if __name__ == "__main__":
    main()

20. 5x5 zero matrix with diagonal: [1,2,3,4,5]

# 5x5 matrix with diagonal
import numpy as np

def main():
    # a = np.array([[1,2,3,4,5],[3,4j,10,np.inf,-10]])
    # print(f"Array A:{a}")
    
    # 5x5 matrix
    mat = np.zeros((5,5))
    #put diagonal in the center
    for i in range(5):
        mat[i,i] = i+1

    print(f"10x10 matrix with border: \n{mat}")


if __name__ == "__main__":
    main()

21. Sum of all elements, sum by col and sum by row

# sum all, sum cols (axis = 0), sum rows (axis = 1)
import numpy as np

def main():
    a = np.array([[1,2,3,4,5],[3,4j,10,-2j,-10]])
    print(f"Array A:{a}")
    

    print(f"Sum of entire array A: \n{np.sum(a)}")
    print(f"Sum of columns in array A: \n{np.sum(a,axis=0)}")
    print(f"Sum of rows array A: \n{np.sum(a,axis=1)}")
    


if __name__ == "__main__":
    main()

22. 4x4 array --> swapping columns

# swap first-last, 2-3 cols
import numpy as np

def main():
    a = np.random.rand(4,4)
    print(F"Array A: \n{a}")
    
    # swap 0-3 and 1-2 cols
    a[:,(0,3)] = a[:,(3,0)]
    a[:,(1,2)] = a[:,(2,1)]

    print(f"Array A after column swap: \n{a}")
    

if __name__ == "__main__":
    main()

23. 4x4 array --> swpping rows

# swap first-last, 2-3 rows
import numpy as np

def main():
    a = np.random.rand(4,4)
    print(F"Array A: \n{a}")
    
    # swap 0-3 and 1-2 rows
    a[(0,3),:] = a[(3,0),:]
    a[(1,2),:] = a[(2,1),:]

    print(f"Array A after row swap: \n{a}")
    


if __name__ == "__main__":
    main()

[AlfredoITS]

Task 1

import numpy as np

def main():
    x = np.array([1, 2, 3,
              4, 6, 7,
              8, 9, 10,
              0, 89, 67])

    print(x)

    if np.all(x):
        print("The array contains no zeroes.")
    else:
        print("It contains zeroes.")

if __name__ == "__main__":
    main()

Task 2

import numpy as np

def main():
    x = np.array([1, 0, 0, 0])
    print(x)
    print("Contains a non-zero?", np.any(x))

    y = np.array([0, 0, 0, 0])
    print(y)
    print("Contains a non-zero?", np.any(y))


if __name__ == "__main__":
    main()

Task 3

import numpy as np

def main():
    x = np.array([1, 0, np.nan, np.inf])
    print(x)
    print("Test for finiteness:\n", np.isfinite(x))

if __name__ == "__main__":
    main()

Task 4

import numpy as np

def main():
    z = np.array([1, 0, np.nan, np.inf])
    print(z)
    print("Test for pos or neg infinity:\n", np.isinf(z))

if __name__ == "__main__":
    main()

Task 5

import numpy as np

def main():
    c = np.array([1, 0, np.nan, np.inf])
    print(c)
    print("Testing for NaN:\n", np.isnan(c))

if __name__ == "__main__":
    main()

Task 6

import numpy as np

def main():
    a = np.array([1 + 1j, 1 + 0j, 4.5, 3, 2, 2j])
    print(a)
    print("Test for complex number:\n", np.iscomplex(a))
    print("Test for real number:\n", np.isreal(a))
    print("Test for scalar type:\n", np.isscalar(3.1), "\n", np.isscalar([3.1]))

if __name__ == "__main__":
    main()

Task 7

import numpy as np

def main():
    print("Test of two arrays:\n")
    print(np.allclose([1e10, 1e-7], [1.00001e10, 1e-8]))
    print(np.allclose([1e10, 1e-8], [1.00001e10, 1e-9]))
    print(np.allclose([1e10, 1e-8], [1.0001e10, 1e-9]))

    print(np.allclose([1.0, np.nan], [1.0, np.nan]))
    print(np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan = True))

if __name__ == "__main__": 
    main()

Task 8

import numpy as np

def main():
    a = np.array([3, 5])
    b = np.array([2, 5])

    print(a, b)

    print("Comparison — Greater: ", np.greater(a, b))
    print("Comparison — Greater Equals: ", np.greater_equal(a, b))
    print("Comparison — Less: ", np.less(a, b))
    print("Comparison — Less Equal: ", np.less_equal(a, b))

if __name__ == "__main__": main()

Task 9

import numpy as np

def main():
    y = np.array([72, 79, 85, 90, 150, -135, 120, -10, 60, 100])
    z = np.array([72, 79, 85, 90, 150, -135, 120, -10, 60, 100.000001])

    print("Arrays:")
    print(y)
    print(z)
    print("Comparison Equal:\n", np.equal(y, z))
    print("Comparison Equal with Tolerance:\n", np.allclose(y, z))

if __name__ == "__main__": main()

Task 10

import numpy as np

def main():
    A = np.array([1, 7, 13, 105])
    print("Array:", A)
    print("Size of the memory used:")
    print("%d bytes" % (A.size * A.itemsize))


if __name__ == "__main__": main()

Task 11

import numpy as np

def main():
    array = np.zeros(10)
    print("Array of Zeroes:\n", array)
    array = np.ones(10)
    print("Array of ones:\n", array)
    array = np.ones(10) * 5
    print("Array of fives:\n", array)

if __name__ == "__main__": main()

Task 12

import numpy as np

def main():
    array = np.arange(30, 71)
    print("Array:\n", array)


if __name__ == "__main__": main()

Task 13

import numpy as np

def main():
    array = np.arange(30, 71, 2)
    print("Array:\n", array)


if __name__ == "__main__": main()

Task 14

import numpy as np

def main():
    array_2D = np.identity(3)
    print("Matrix:\n", array_2D)


if __name__ == "__main__": main()

Task 15

import numpy as np

def main():
    random = np.random.normal(0, 1, 1)
    print("Random Number: ", random)

if __name__ == "__main__": main()

Task 16

import numpy as np

def main():
    rannum = np.random.normal(0, 1, 15)
    print("Random numbers:\n", rannum)

if __name__ == "__main__": main()

Task 17

import numpy as np

def main():
    num = np.arange(10, 22).reshape((3, 4))
    print("Matrix:\n", num)
    print("# Rows and # Columns:\n", num.shape)

if __name__ == "__main__": main()

Task 18

import numpy as np

def main():
    m = np.eye(3)
    print(m)

if __name__ == "__main__": main()

Task 19

import numpy as np

def main():
    z = np.ones((10, 10))
    z[1:-1, 1:-1] = 0
    print(z)

if __name__ == "__main__": main()

Task 20

import numpy as np

def main():
    y = np.diag([1, 2, 3, 4, 5])
    print(y)

if __name__ == "__main__": main()

Task 21

import numpy as np

def main():
    a = np.array([[0, 1], [2, 3]])
    print("Array:\n", a)
    print("Sum of all: ", np.sum(a))
    print("Sum of columns: ", np.sum(a, axis = 0))
    print("Sum of rows: ", np.sum(a, axis = 1))

if __name__ == "__main__": main()

Task 22 & 23

import numpy as np

def main():
    nums = np.arange(16, dtype = 'int').reshape(-1, 4)
    print("OG Array:\n", nums)
    print("New Array:")
    new_nums = nums[:, ::-1]
    print(new_nums)
    

if __name__ == "__main__": main()

[rama77605]

Task1
import numpy as np
x = np.array([[1, 2, 3],[4,5,6]])
print(" array:")
print(x)
print("none of the elements of the said array is zero:")
print(np.all(x))
#Task2

x = np.array([[0, 1, 2, 3],[0,4,5,6]])
print(" array:")
print(x)
print(" none of the elements of the said array is zero:")
print(np.all(x))
#Task3
import numpy as np
a = np.array([1, 0, np.nan, np.inf])
print("Original array")
print(a)
print("Test a given array element-wise for finiteness :")
print(np.isfinite(a))

[Edson-Rodrigo]

1.-

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 0])
test = np.isin(0, arr)
if test:
    print("There are zeros in the array")
else:
    print("There are no zeros in the array")

2.-

import numpy as np
arr = np.array([(1, 2, 3, 4, 5), (6, 7, 8, 9, 0)])
test = np.count_nonzero(arr)
print(f"In the given arrays there are {len(arr)} elements which {test} are not zeros")

3.-

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 0, np.nan, np.inf])
finite = np.isfinite(arr)
print(arr)
print(f"Test for finiteness\n{finite}")

4.-

import numpy as np
print("Cheching for positive infinity\nResult is:", np.isinf(np.inf))
print("Cheching for negative infinity\nThe Result is:", np.isinf(np.NINF))

5.-

import numpy as np
arr = np.array([1,2,3, np.NaN])
print("Original array\n", arr)
print("Testo elemnt-wise for NaN:\n", np.isnan(arr))

6.-

import numpy as np
arr = np.array([1, 2, 3, 2j])
print("Original array\n", arr)
print("Checking for real number:\n",np.isreal(arr))
print("Checking for complex number:\n",np.iscomplex(arr))
print("Checking for scalar number:\n",np.isscalar(4.5))

7.-

import numpy as np
a = np.array([1, 2, 3, 4, 5])
b = np.array([1, 2, 3, 5, 7])
c = np.allclose(a, b, atol=1)
print(c)

8.-

import numpy as np
a = ([1,2,3,4,5])
b = ([1,9,0,4,10])
print("Original array A")
print(a)
print("Original array B")
print(b)
print("A > B")
print(np.greater(a, b))
print()
print("A >= B")
print(np.greater_equal(a, b))
print()
print("A < B")
print(np.less(a, b))
print()
print("A <= B")
print(np.less_equal(a, b))
print()

9.-

import numpy as np
a = ([1,2,3,4,5])
b = ([1,9,0,4,6])
print("Original array A")
print(a)
print("Original array B")
print(b)
print("A = B")
print(np.equal(a, b))
print()
print("A = B with tolerance")
abs_tol = 1
print(np.isclose(a, b, atol = abs_tol))

10.-

import numpy as np
a = np.array([1, 7, 13, 105])
print("The memory size of the array given is:")
print(a.size * a.itemsize)

11.-

import numpy as np
a = np.zeros(10)
print("An array of 10 zeros")
print(a)
a = np.ones(10)
print("An array of 10 ones")
print(a)
a = np.ones(10)
a = a * 5
print("An array of 10 fives")
print(a)

12.-

import numpy as np
a = np.array(range(30,71))
print(a)

13.-

import numpy as np
a = np.array([x for x in range(30,71) if x % 2 == 0])
print("An array of even number from 30 to 70 is:")
print(a)

14.-

import numpy as np
a = np.identity(3)
print(a)

15.-

import numpy as np
rng = np.random.uniform(0, 1)
a = rng
print(a)

16.-

import numpy as np
ran_num =np.random.normal(0,1,15)
print("Array of random numbers:")
print(ran_num)

17.-

import numpy as np
a = np.array([(1, 2, 3, 4, 5), (5, 6, 7, 8, 9)])
m = np.asmatrix(a)
print("Original matrix: \n", m)
print("The size of the matrix is:")
print(m.shape)

18.-

import numpy as np
a = np.identity(3)
m = np.asmatrix(a)
print(a)

19.-

import numpy as np
a = np.ones([10,10])
a[1:9, 1:9] = 0
print(a)

20.-

import numpy as np
a = np.zeros([5, 5])
a[0,0] = 1
a[1,1] = 2
a[2,2] = 3
a[3,3] = 4
a[4,4] = 5
print(a)

21.-

import numpy as np
a = np.array([(1,2,3),(4,5,6),(7,8,9)])
print("Original array:")
print(a)
sum = np.sum(a)
sum_rows = np.sum(a, 1)
sum_column = np.sum(a, 0)
print("The sum of all elements is:")
print(sum)
print("The sum of each row is:\n 1st 2nd 3rd")
print(sum_rows)
print("The sum of each column is:\n 1st 2nd 3rd")
print(sum_column)

22.-

import numpy as np
a = np.random.rand(4, 4)
print("Original array:")
print(a)
print()
b = a
print("Swapping first and last, second and third columns:")
print(np.fliplr(b))

23.-

import numpy as np
a = np.random.rand(4, 4)
print("Original array:")
print(a)
print()
b = a
print("Swapping first and last, second and third rows:")
print(np.flipud(b))

[JesusBel16]

import numpy as nup
arr = nup.array([4, 1, 2, 3])
if nup.isin(0, arr):
    print("It has zero")
else:
    print("Free from zeros")

import numpy as nup
arr = nup.array([0, 1, 2, 3])
if nup.all(nup.isfinite(arr)):
    print("It's finite")
else:
    print("It's not finite")

import numpy as nup
arr = nup.array([1, 1, 2, 3, nup.inf])
print("Positive infinite evaluation", nup.any(nup.isposinf(arr)))
print("Negative infinite evaluation", nup.any(nup.isneginf(arr)))

[Gayathrivinodh]

#1.

import numpy as np
x = np.array([1, 0, 0, 0])
print("Original array:")
print(x)
print("Test whether any of the elements of a given array is non-zero:")
print(np.any(x))
x = np.array([0, 0, 0, 0])
print("Original array:")
print(x)
print("Test whether any of the elements of a given array is non-zero:")
print(np.any(x))

#2.

import numpy as np
x = np.array([1, 2, 3, 4])
print("Original array:")
print(x)
print("Test if all of the elements in array is zero:")
print(np.all(x))
x = np.array([0, 1, 2, 3])
print("Original array:")
print(x)
print("Test if all of the elements in array is zero:")
print(np.all(x))

#3.

import numpy as np
  
# Returns True/False value for each element
b = np.arange(20).reshape(5, 4)
                
print("\n",b)
print("\nIs Finite : \n", np.isfinite(b))
 
 
b = [[1j],
     [np.inf]]
print("\nIs Finite : \n", np.isfinite(b))

#4.

import numpy as np
  
# Returns True/False value for each element
b = np.arange(18).reshape(3, 6)
                
print("\n",b)
print("\nIs Positive Infinity : \n", np.isposinf(b))
 
# np.inf means Infinity
# np.NINF means negative infinity
b = [[np.inf],
     [np.NINF]]
print("\nIs Positive Infinity : \n", np.isposinf(b))

#5.

import numpy as np
a = np.array([1, 0, np.nan, np.inf,4])
print("Original array")
print(a)
print("Test element-wise for NaN:")
print(np.isnan(a))

#6.

import numpy as np
b = np.array([1+1j,2+2j,3+3j,3,4,3j])
print("original array")
print(b)
print("Checking for complex number:")
print(np.iscomplex(b))
print("Checking for real number:")
print(np.isreal(b))
print("Checking for scalar type:")
print(np.isscalar(4.1))
print(np.isscalar([3.1]))

#7.

import numpy as np
print("Test if two arrays are element-wise equal within a tolerance:")
print(np.allclose([1e10,1e-7], [1.00001e10,1e-8]))
print(np.allclose([1e10,1e-8], [1.00001e10,1e-9]))
print(np.allclose([1e10,1e-8], [1.0001e10,1e-9]))
print(np.allclose([1.0, np.nan], [1.0, np.nan]))
print(np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True))

#8.

import numpy as np
x = np.array([3, 5])
y = np.array([2, 5])
print("Original numbers:")
print(x)
print(y)
print("Comparison - greater")
print(np.greater(x, y))
print("Comparison - greater_equal")
print(np.greater_equal(x, y))
print("Comparison - less")
print(np.less(x, y))
print("Comparison - less_equal")
print(np.less_equal(x, y))

#9.

import numpy as np
x = np.array([72, 79, 85, 90, 150, -135, 120, -10, 60, 100])
y = np.array([72, 79, 85, 90, 150, -135, 120, -10, 60, 100.000001])
print("Original numbers:")
print(x)
print(y)
print("Comparison - equal:")
print(np.equal(x, y))
print("Comparison - equal within a tolerance:")
print(np.allclose(x, y))

#10.

x = np.array([[1, 7, 13,105]])
 
print("Size of the array: ",
      x.size)
 
print("Memory size of one array element in bytes: ",
      x.itemsize)
 
# memory size of numpy array
print("Memory size of numpy array in bytes:",
      x.size * x.itemsize)

#11.

import numpy as np
array=np.zeros(10)
print("An array of 10 zeros:")
print(array)
array=np.ones(10)
print("An array of 10 ones:")
print(array)
array=np.ones(10)*5
print("An array of 10 fives:")
print(array)

#12.

import numpy as np
array=np.arange(30,71)
print("Array of the integers from 30 to70")
print(array)

#13.

import numpy as np
array=np.arange(30,71,2)
print("Array of all the even integers from 30 to 70")
print(array)

#15.

import numpy as np
rand_num = np.random.normal(0,1,1)
print("Random number between 0 and 1:")
print(rand_num)

#16.

import numpy as np
rand_num = np.random.normal(0,1,15)
print("15 random numbers from a standard normal distribution:")
print(rand_num)

#17.

import numpy as np

matrix= np.arange(10,16).reshape((3, 2))
print(matrix)
print(matrix.shape)

#14.

import numpy as np
array_2D=np.identity(3)
print('3x3 matrix:')
print(array_2D)

#18.

import numpy as np
x = np.ones((10, 10))
x[1:-1, 1:-1] = 0
print(x)

#19.

import numpy as np
x= np.zeros((5,5))
x= np.diag([1,2,3,4,5])
print(x)

#20.

import numpy as np
x = np.array([[2,4],[5,6]])
print("Original array:")
print(x)
print("Sum of all elements:")
print(np.sum(x))
print("Sum of each column:")
print(np.sum(x, axis=0))
print("Sum of each row:")
print(np.sum(x, axis=1))

#21.

import numpy as np 
nums = np.arange(16, dtype='int').reshape(-1, 4)
print("Original array:")
print(nums)
print("\nNew array after swapping first and last rows of the said array:")
new_nums = nums[::-1]
print(new_nums)

[KevinIturbe]

#1
import numpy as np
list = np.array([1,2,3,4,5])
#2
check = np.isin(0,list)
print(check)

#3
import numpy as np
list = np.array([1,2,3,4,5,0])
#4
check1 = np.not_equal(0,list)
print(check1)
#5
import numpy as np

list2 = np.array([1,2,3,4])
#6
check2 = np.isposinf(list2)
print(check2)

#7import numpy as np

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

checkNeg = np.isneginf(list2)

print(checkNeg)
#8
import numpy as np

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

check4=np.isnan(list)
print(list)
#9
import numpy as np

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

#0
check5=np.iscomplex(list)
check6=np.isreal(list)
check7=np.isscalar(list)


list1=np.array([1,2,3,4])
list2=np.array([5,6,7,8])
#10

equal=np.array_equal(list1,list2)
greater=np.greater(list1,list2)
equal= np.equal(list1,list2)



print(equal)
print(greater)
list=np.array([5,6,7,8,4.4])

totalBytes=list.nbytes
print(totalBytes)


zeros=np.zeros(10, dtype=int)
ones=np.ones(10, dtype=int)
fives=np.array([5]*10)
finalArray= [[zeros],[ones],[fives]]
print(zeros)
print(ones)
print(fives)
print(finalArray)

##12
exercise12 = np.arange(30,71)
print(exercise12)
##13
exercise13= np.arange(30,71,2)
print(exercise13)
##14
exercise14=np.arange(9).reshape((3,3))
print(exercise14)
##15
from numpy.random import default_rng
exercise15=default_rng().random(1)
print(exercise15)
##16
from numpy.random import default_rng
exercise16= default_rng().random(15)
print(exercise16)

##17
arr=np.array([[1,2,3],[1,2,3]])
exercise17=arr.shape
print(exercise17)

##18
exercise18=np.eye(3)
print(exercise18)

##19
exercise19=np.ones((10,10), dtype=int)
exercise19[1:-1, 1:-1] = 0
print(exercise19)

##20
exercise20=np.diag([1,2,3,4,5])
print(exercise20)

##21
arr=np.array([[1,2,3,4,5],[6,5,8,9,2]])
exercise21=print(np.sum(arr))

##22
arr=np.array([[1,2,1,2],[4,3,4,5],[6,5,8,9],[6,7,6,7]])
arrRev=np.fliplr(arr)
print(arrRev)

##23

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

[zenberr]

1. Write a NumPy program to test whether none of the elements of a given array is zero.

import numpy as np
x = np.array([[1, 2, 3],
		[4, 6, 7],
		[8, 0, 10]])
			
if np.all(x):
    print("No zeros")
else:
    print("Have zeros")

2. Write a NumPy program to test whether any of the elements of a given array is non-zero.

import numpy as np
x = np.array([[0, 0, 0],
		[0, 0, 0],
		[0, 0, 1]])
			
if np.any(x):
    print("It have non-zero values")
else:
    print("All values are zeros")

3. Write a NumPy program to test a given array element-wise for finiteness (not infinity or not a Number).

import numpy as np

x = np.array([[0, 0, np.inf],
		[0, 0, 0],
		[0, 0, 1]])
			
print(np.isfinite(x))

4. Write a NumPy program to test element-wise for positive or negative infinity.

import numpy as np

x = np.array([np.NINF, 0, np.inf])

print(np.isinf(x[0]))
print(x[0])
print(np.isinf(x[1]))
print(x[1])
print(np.isinf(x[2]))
print(x[2])

5. Write a NumPy program to test element-wise for NaN of a given array.

import numpy as np

x = np.array([np.log(-1.),1.,np.inf])

print(np.isnan(x))

6. Write a NumPy program to test element-wise for complex number, real number of a given array. Also test whether a given number is a scalar type or not.

import numpy as np

x = np.array([[1+1j, 1+2j, 3],
		[2j, 3.4, 0],
		[0, 0, 1]])
			
print("Have complex numbers? \n",np.iscomplex(x))
print("\nHave real numbers? \n",np.isreal(x))
print("\n3.1 is scalar number? \n",np.isscalar(3.1))

7. Write a NumPy program to test whether two arrays are element-wise equal within a tolerance.

import numpy as np
print("Equal within a tolerance?")
print(np.allclose([1], [1.00000001]))

8. Write a NumPy program to create an element-wise comparison (greater, greater_equal, less and less_equal) of two given arrays.

import numpy as np
a = np.array([1,5,4,5])
b = np.array([2,3,4,5])
print("Is greater: ",np.greater(a,b))
print("Is greater equal: ",np.greater_equal(a,b))
print("Is less: ",np.less(a,b))
print("Is less equal: ",np.less_equal(a,b))

9. Write a NumPy program to create an element-wise comparison (equal, equal within a tolerance) of two given arrays.

import numpy as np
a = np.array([1,3,4,4.999999999999])
b = np.array([1,3,4.0000000001,5])
print("Is equal: ",np.equal(a,b))
print("Is equal within a tolerance: ",np.allclose(a,b))

10. Write a NumPy program to create an array with the values 1, 7, 13, 105 and determine the size of the memory occupied by the array.

import numpy as np
a = np.array([1, 7, 13, 105])
print("%d bytes" % (a.size * a.itemsize))

11. Write a NumPy program to create an array of 10 zeros,10 ones, 10 fives.

import numpy as np
a = ([[np.zeros(10)],[np.ones(10)],[np.ones(10)*5]])
print(a)

12. Write a NumPy program to create an array of the integers from 30 to70.

import numpy as np
a = np.arange(30,70+1)
print(a)

13. Write a NumPy program to create an array of all the even integers from 30 to 70.

import numpy as np
a = np.arange(30,70+1,2)
print(a)

14. Write a NumPy program to create a 3x3 identity matrix.

import numpy as np
a = np.identity(3)
print(a)

15. Write a NumPy program to generate a random number between 0 and 1.

import numpy as np
a = np.random.normal(0,1,1)
print(a)

16. Write a NumPy program to generate an array of 15 random numbers from a standard normal distribution.

import numpy as np
a = np.random.normal(0,1,15)
print(a)

17. Write a NumPy program to find the number of rows and columns of a given matrix.

import numpy as np
a = np.arange(10,22).reshape((3, 4))
print(a.shape)

18. Write a NumPy program to create a 3x3 identity matrix, i.e. diagonal elements are 1, the rest are 0.

import numpy as np
a = np.identity(3)
print(a)

19. Write a NumPy program to create a 10x10 matrix, in which the elements on the borders will be equal to 1, and inside 0.

import numpy as np
a = np.ones((10, 10))
a[1:-1, 1:-1] = 0
print(a)

20. Write a NumPy program to create a 5x5 zero matrix with elements on the main diagonal equal to 1, 2, 3, 4, 5.

import numpy as np
a = np.diag([1, 2, 3, 4, 5])
print(a)

21. Write a NumPy program to compute sum of all elements, sum of each column and sum of each row of a given array.

import numpy as np
arr = np.array([[23,1],[42,30]])
print("Total sum",np.sum(arr))
print("Sum of each column:",np.sum(arr, axis=0))
print("Sum of each row:",np.sum(arr, axis=1))

22. Write a NumPy program to create a 4x4 array, now create a new array from the said array swapping first and last, second and third columns.

import numpy as np 
arr1 = np.arange(16).reshape(-1, 4)
print(arr1)
arr2 = nums[:, ::-1]
print(arr2)

23. Write a NumPy program to create a 4x4 array, now create a new array from the said array swapping first and last, second and third columns.

import numpy as np 
arr1 = np.arange(16).reshape(-1, 4)
print(arr1)
arr2 = nums[:, ::-1]
print(arr2)

[rama77605]

#Task4
import numpy as np
a = np.array([[1, 0, np.nan, np.inf],[0,1,-np.nan,np.inf]])
print("Original array")
print(a)
print(" positive or negative infinity:")
print(np.isinf(a))
#task5
import numpy as np
a = np.array([1, 0, np.nan, np.inf])
print("Original array")
print(a)
print(" NaN:")
print(np.isnan(a))
#task6
import numpy as np
a = np.array([2+5j, 6+0j, 4.5, 3, 2, 2j])
print("Original array")
print(a)
print(" complex number:")
print(np.iscomplex(a))
print("Checking for real number:")
print(np.isreal(a))
print(" scalar type:")
print(np.isscalar(6.1))
print(np.isscalar([6]))

[eusoj2]

1.-

import numpy as np
array = np.array([32, 4, 34, 12])
if not np.isin(0, array):
    print("no 0´s")
else:
    print("has 0´s")

2.-

import numpy as np
array = np.array([0, 0, 0, 0, 0, 89])
if not np.any(array):
    print("has only 0´s")
else:
    print("not has only 0´s")

3.-

import numpy as np
a = np.array([1, 0, np.nan, np.inf])
print("Test a given array element-wise for finiteness :")
print(np.isfinite(a))

4.-

import numpy as np
a = np.array([1, 0, np.nan, np.inf])
print(np.isinf(a))

5.-

import numpy as np
a = np.array([1, 0, np.nan, np.inf])
print(np.isnan(a))

6.-

import numpy as np
a = np.array([1+1j, 1+0j, 4.5, 3, 2, 2j])
print("complex number: ", np.iscomplex(a))
print("real number: ", np.isreal(a))
print("scalar type: ", np.isscalar(7.8))

7.-

import numpy as np

print("equal with a tolerance: ", np.allclose([1.0, np.nan], [1.0, np.nan]))
print("equal with a tolerance: ", np.allclose([1e10,1e-8], [1.00001e10,1e-9]))

8.-

import numpy as np
arr1 = np.array([4, 7])
arr2 = np.array([5, 9])
print("greater : ", np.greater(arr1, arr2))
print("greater_equal : ", np.greater_equal(arr1, arr2))
print("less : ", np.less(arr1, arr2))
print("less_equal : ", np.less_equal(arr1, arr2))

9.-

import numpy as np
arr1 = np.array([4, 7, 120, 25.0001])
arr2 = np.array([4, 7, 120, 25])
print("equal: ", np.equal(arr1, arr2))
print("equal within a tolerance:", np.allclose(arr1, arr2))

10.-

import numpy as np
arr1 = np.array([1, 7, 13, 105])
print("%d bytes" % (arr1.size * arr1.itemsize))

11.-

import numpy as np
arr1 = np.zeros(10)
arr2 = np.ones(10)
arr3 = np.ones(10)*5
print(arr1, "\n", arr2, "\n", arr3)

12.-

import numpy as np
print(np.arange(30, 71))

13.-

import numpy as np
print(np.arange(30, 71, 2))

14.-

import numpy as np
print(np.identity(3))

15.-

import numpy as np
print(np.random.normal(0,1,1))

16.-

import numpy as np
print(np.random.normal(0,1,15))

17.-

import numpy as np
matrix = np.arange(13,22).reshape((3, 3))
print(matrix.shape)

18.-

import numpy as np
print(np.eye(3))

19.-

import numpy as np
matrix = np.ones((10, 10))
matrix[1:-1, 1:-1] = 0
print(matrix)

20.-

import numpy as np
print(np.diag([1, 2, 3, 4, 5]))

21.-

import numpy as np
x = np.array([[0,1],[2,3],[4,5]])
print("Sum of all elements:", np.sum(x))
print("Sum of each column:", np.sum(x, axis=0))
print("Sum of each row:", np.sum(x, axis=1))

22.-

import numpy as np
matrix = np.arange(16, dtype='int').reshape(4, 4)
newmatrix = matrix[:, ::-1]
print(matrix)
print(newmatrix)

23.-

import numpy as np
matrix = np.arange(16, dtype='int').reshape(4, 4)
newmatrix = matrix[:, ::-1]
print(matrix)
print(newmatrix)

[Jyothig7]

#1.Write a NumPy program to test whether none of the elements of a given array is zero.

import numpy as np

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

if np.all(arr):
    
    print("No zeros")
else:
    print("Yes zeros are there")

2.Write a NumPy program to test whether any of the elements of a given array is non-zero.

import numpy as np

arr = np.array([[0,0,0,0,0],[0,0,0,0,0]])

if np.all(arr):
    
    print("No zeros")
else:
    print("Yes zeros are there")

3.Write a NumPy program to test a given array element-wise for finiteness (not infinity or not a Number).

import numpy as np
a = np.array([1, 0, np.nan, np.inf])
print("Original array")
print(a)
print("Test a given array element-wise for finiteness :")
print(np.isfinite(a))

4.Write a NumPy program to test element-wise for positive or negative infinity.

import numpy as np
a = np.array([1, 0, np.nan, np.inf])
print("Original array")
print(a)
print("Test element-wise for positive or negative infinity:")
print(np.isinf(a))

5.Write a NumPy program to test element-wise for NaN of a given array.

import numpy as np
a = np.array([1, 0, np.nan, np.inf])
print("Original array")
print(a)
print("Test element-wise for NaN:")
print(np.isnan(a))

6.Write a NumPy program to test element-wise for complex number, real number of a given array. Also test whether a given number is a scalar type or not.

import numpy as np
a = np.array([1+1j, 1+0j, 4.5, 3, 2, 2j])
print("Original array")
print(a)
print("Checking for complex number:")
print(np.iscomplex(a))
print("Checking for real number:")
print(np.isreal(a))
print("Checking for scalar type:")
print(np.isscalar(3.1))
print(np.isscalar([3.1]))

7.Write a NumPy program to test whether two arrays are element-wise equal within a tolerance.

import numpy as np
print("Test if two arrays are element-wise equal within a tolerance:")
print(np.allclose([1e10,1e-7], [1.00001e10,1e-8]))
print(np.allclose([1e10,1e-8], [1.00001e10,1e-9]))
print(np.allclose([1e10,1e-8], [1.0001e10,1e-9]))
print(np.allclose([1.0, np.nan], [1.0, np.nan]))
print(np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True))

8Write a NumPy program to create an element-wise comparison (greater, greater_equal, less and less_equal) of two given arrays..

import numpy as np
x = np.array([3, 5])
y = np.array([2, 5])
print("Original numbers:")
print(x)
print(y)
print("Comparison - greater")
print(np.greater(x, y))
print("Comparison - greater_equal")
print(np.greater_equal(x, y))
print("Comparison - less")
print(np.less(x, y))
print("Comparison - less_equal")
print(np.less_equal(x, y))

9.Write a NumPy program to create an element-wise comparison (equal, equal within a tolerance) of two given arrays.

import numpy as np
x = np.array([72, 79, 85, 90, 150, -135, 120, -10, 60, 100])
y = np.array([72, 79, 85, 90, 150, -135, 120, -10, 60, 100.000001])
print("Original numbers:")
print(x)
print(y)
print("Comparison - equal:")
print(np.equal(x, y))
print("Comparison - equal within a tolerance:")
print(np.allclose(x, y))

10.Write a NumPy program to create an array with the values 1, 7, 13, 105 and determine the size of the memory occupied by the ##array.

import numpy as np
X = np.array([1, 7, 13, 105])
print("Original array:")
print(X)
print("Size of the memory occupied by the said array:")
print("%d bytes" % (X.size * X.itemsize))

11.Write a NumPy program to create an array of 10 zeros,10 ones, 10 fives.

import numpy as np
array=np.zeros(10)
print("An array of 10 zeros:")
print(array)
array=np.ones(10)
print("An array of 10 ones:")
print(array)
array=np.ones(10)*5
print("An array of 10 fives:")
print(array)

12.Write a NumPy program to create an array of the integers from 30 to70.

import numpy as np
array=np.arange(30,71)
print("Array of the integers from 30 to70")
print(array)

```python
13.Write a NumPy program to create an array of all the even integers from 30 to 70.
```python

import numpy as np
array=np.arange(30,71,2)
print("Array of all the even integers from 30 to 70")
print(array) 

import numpy as np
array_2D=np.identity(3)
print('3x3 matrix:')
print(array_2D)

import numpy as np
rand_num = np.random.normal(0,1,1)
print("Random number between 0 and 1:")
print(rand_num)

import numpy as np
rand_num = np.random.normal(0,1,15)
print("15 random numbers from a standard normal distribution:")
print(rand_num)

17

import numpy as np
m= np.arange(10,22).reshape((3, 4))
print("Original matrix:")
print(m)
print("Number of rows and columns of the said matrix:")
print(m.shape)

import numpy as np
x = np.eye(3)
print(x)

import numpy as np
x = np.ones((10, 10))
x[1:-1, 1:-1] = 0
print(x)

20

import numpy as np
a = np.diag([1, 2, 3, 4, 5])
print(a)

import numpy as np 
nums = np.arange(16, dtype='int').reshape(-1, 4)
print("Original array:")
print(nums)
print("\nNew array after swapping first and last rows of the said array:")
new_nums = nums[::-1]
 #print(new_nums)

import numpy as np 
nums = np.arange(16, dtype='int').reshape(-1, 4)
print("Original array:")
print(nums)
print("\nNew array after swapping first and last columns of the said array:")
new_nums = nums[:, ::-1]
print(new_nums)

import numpy as np 
nums = np.arange(16, dtype='int').reshape(-1, 4)
print("Original array:")
print(nums)
print("\nNew array after swapping first and last columns of the said array:")
new_nums = nums[:, ::-1]
print(new_nums)

[rama77605]

#TASK7
import numpy as np
print("Test if two arrays are element-wise equal within a tolerance:")
print(np.allclose([1e10,1e-7], [1.00001e10,1e-8]))
print(np.allclose([1e10,1e-8], [1.00001e10,1e-9]))
print(np.allclose([1e10,1e-8], [1.0001e10,1e-9]))
print(np.allclose([1.0, np.nan], [1.0, np.nan]))
print(np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True))

#TASK8

import numpy as np
x = np.array([3, 5])
y = np.array([2, 5])
print("Original numbers:")
print(x)
print(y)
print("Comparison - greater")
print(np.greater(x, y))
print("Comparison - greater_equal")
print(np.greater_equal(x, y))
print("Comparison - less")
print(np.less(x, y))
print("Comparison - less_equal")
print(np.less_equal(x, y))

#TASK9
import numpy as np
x = np.array([72, 79, 85, 90, 150, -135, 120, -10, 60, 100])
y = np.array([72, 79, 85, 90, 150, -135, 120, -10, 60, 100.000001])
print("Original numbers:")
print(x)
print(y)
print("Comparison - equal:")
print(np.equal(x, y))
print("Comparison - equal within a tolerance:")
print(np.allclose(x, y))

[rama77605]

#TASK10
import numpy as np
arr = np.array([1, 7,13,105])
print("%d bytes" % (arr.size * arr.itemsize))

#TASK11
import numpy as np
arr1 = np.zeros(10)
arr2 = np.ones(10)
arr3 = np.ones(10)*5
print(arr1, "\n", arr2, "\n", arr3)

#TASK12
import numpy as np
array=np.arange(30,71)
print(" integers from 30 to70")
print(array)

#TASK13
import numpy as np
array=np.arange(30,71,2)
print(" integers from 30 to70" )
print(array)

#TASK14
import numpy as np
array=np.identity(3,dtype=int)
print('3x3 matrix:')
print(array)

#TASK15
import numpy as np
array=np.random.uniform(0,1)
print(array)


#TASK16
import numpy as np
array=np.random.normal(0,1,15)
print(array)

[rama77605]

#TASK17
import numpy as np
arr = np.array([[1, 7],[2,3],[4,5]])
print(np.shape(arr))


#TASK18
import numpy as np

print(np.identity(3,dtype=int))

#TASK19
import numpy as np
arr = np.ones((10,10))*10
arr[1:-1, 1:-1,] = 0
print(arr)

#Task20
import numpy as np
arr = np.zeros((5, 5))
for i in range(len(arr)):
    arr[i][i] = i+1
print(arr)

#TASK21
import numpy as np
arr = np.array([[1, 3, 4], [1, 2, 3]])
print(f"{arr} \n")
print(f"{np.sum(arr, axis=1)} is the sum of each row \n{np.sum(arr, axis=0)} is the sum of each column")

#TASK22
import numpy as np
a = np.random.rand(4,4)
print(F"Array A: \n{a}")    
a[:,(0,3)] = a[:,(3,0)]
a[:,(1,2)] = a[:,(2,1)]
print(f"Array A after column swap: \n{a}")

#TASK23
import numpy as np
a = np.random.rand(4,4)
print(F"Array A: \n{a}")    
a[(0,3),:] = a[(3,0),:]
a[(1,2),:] = a[(2,1),:]
print(f"Array A after column swap: \n{a}")