Creating Numpy Arrays - Numpy for Data Science - Part 1 || CODING SNAP ||

Numpy for Data Science - Part 1

NUMPY is used in various fields such as Machine Learning, Artificial Intelligence, Computer Graphics, Physics, etc.

• Numpy stands for Numerical Python, most of the scientific computations are made easy using Numpy.
• It basically contains methods that deal with high-level computations on integers and floating-point values.
• The positive outlook of Numpy containers is that the lists operations such as insert and append are costless. Also, the lookup on dictionaries is fast.
• It is an extension package to Python for multi-dimensional arrays.
• The implementations of NumPy methods are closer to the hardware. Hence, it provides efficiency.
• Designed for scientific computations that provide great convenience.
• Also known as array-oriented computing.

Proving the Fact that Numpy arrays are efficient than Python Lists

If we create a NumPy array and square up all the elements in it and do the same with the list of python. Then the time taken in this overall process is:

	#Numpy Array
	a = np.arange(1000)
	%timeit a**2
	Output: 3.54 µs ± 87.3 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
	#Python List
	L = range(1000)
	%timeit [i**2 for i in L]
	Output: 795 µs ± 50 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

view raw Performance.py hosted with ❤ by GitHub

The difference in the operational time can be clearly seen. Numpy arrays perform exceptionally well in comparison to the Python lists.

Creating an array in Numpy

There are several ways for creating an array in Numpy

1. We can create an array using the array() method that takes in the list of values of an array.

	import numpy as np
	a = np.array([1,2,3,4,5])
	print("A :",a)
	Output: A : [1 2 3 4 5]

view raw CreatingArray1.py hosted with ❤ by GitHub

2. We can also create the array using the arange() method. 

"arange" stands for the array range of numbers. The array consists of the elements according to the values passed as the parameter. the default start value is 0 and the end value is always (n-1), we can also specify a step value if required.

	a = np.arange(10)
	b = np.arange(2,20,4)
	print("Array A =",a)
	print("Array B =",b)
	Output:
	Array A = [0 1 2 3 4 5 6 7 8 9]
	Array B = [ 2 6 10 14 18]

view raw CreatingArray2.py hosted with ❤ by GitHub

3. We can also define and initialize an array using the random() method. If we use the random.rand() then it returns the float values between 0 and 1 of the specified size.

	a = np.random.rand(5) #5 is the number of elements we want in the array
	print(a)
	Output:
	[0.52759507 0.62328844 0.26818125 0.78392403 0.36929455]

view raw CreatingArray3.py hosted with ❤ by GitHub

4. If we want to use the random values but only integers then we should use the randint(). Here, we have to pass three arguments: begin, end, NoOfElements.

Note: The values can be repeated.

	a = np.random.randint(0,20,15)
	print(a)
	Output:
	[10 4 6 13 9 6 1 11 6 11 5 0 11 4 0]

view raw CreatingArray4.py hosted with ❤ by GitHub

5. If we want to create an array with values that have equal intervals within a certain range then we can use the linspace(). 

Note1: We need to pass the start value as well as the end value, along with the number of elements we want. 
Note2: The values are float by default.

	a = np.linspace(1,10,5)
	print(a)
	Output:
	[ 1. 3.25 5.5 7.75 10. ]

view raw CreatingArray5.py hosted with ❤ by GitHub

Creating 2-Dimensional arrays

We can create two-dimensional arrays by passing the two lists of values. Check below

	a = np.array([[1,2,3,4],[5,6,7,8]])
	print(a)
	Output:
	[[1 2 3 4]
	[5 6 7 8]]

view raw CreatingArray6.py hosted with ❤ by GitHub

Creating a 3-Dimensional arrays

It is the same as creating the 2D array, except the fact that we need to specify the dimensions within the square brackets.

	a = np.array([[[1,2],[3,4]],[[5,6],[7,8]]])
	print(a)
	Output:
	[[[1 2]
	[3 4]]
	[[5 6]
	[7 8]]]

view raw CreatingArray7.py hosted with ❤ by GitHub

It can be interpreted as the Lists of Lists of Lists(or lists within a list and pair of these lists within a major list).

Methods to Leverage on!

Suppose, you want to create an array that contains only zero in it. Then zeros() function can be used.

By default, the values are in float.

We can also create a matrix of zeros by specifying the set of values for rows and columns.

	a = np.zeros(4)
	print(a)
	Output: [0. 0. 0. 0.]
	a = np.zeros((3,4))
	print(a)
	Output:
	[[0. 0. 0. 0.]
	[0. 0. 0. 0.]
	[0. 0. 0. 0.]]

view raw Zeros.py hosted with ❤ by GitHub

We can also create a matrix of zeros by specifying the set of values for rows and columns.

Now, suppose you want an array with the values only 1. Then we can use the ones() method. Note: The values are in float by default.

Also, see how we can create a 5X5 matrix of 1.

	a = np.ones(5)
	print(a)
	Output: [1. 1. 1. 1. 1.]
	a = np.ones((5,5))
	print(a)
	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.]]

view raw Ones.py hosted with ❤ by GitHub

Creating an Identity matrix using the eye() method. If one value n is passed then, a matrix of nXn is created. 
Note: The values are float by default.

	a = np.eye(5)
	print(a)
	Output:
	[[1. 0. 0. 0. 0.]
	[0. 1. 0. 0. 0.]
	[0. 0. 1. 0. 0.]
	[0. 0. 0. 1. 0.]
	[0. 0. 0. 0. 1.]]
	#Column < Rows
	a = np.eye(5,3)
	print(a)
	Output:
	[[1. 0. 0.]
	[0. 1. 0.]
	[0. 0. 1.]
	[0. 0. 0.]
	[0. 0. 0.]]

view raw Eye.py hosted with ❤ by GitHub

Creating a Diagonal matrix using the diag() method. A list of values is passed as an argument, the values are the values of the diagonal.

	a = np.diag([1,2,3,4])
	print(a)
	Output:
	[[1 0 0 0]
	[0 2 0 0]
	[0 0 3 0]
	[0 0 0 4]]

view raw Diagonal.py hosted with ❤ by GitHub

If we want to extract the diagonal values, from the matrix then we can use the diag() method by passing the matrix.

	np.diag(a)
	Output: array([1, 2, 3, 4])

view raw Diagonal2.py hosted with ❤ by GitHub