Pretty cool!

NumPy is a library for the Python, adding support for large, multi-dimensional arrays and matrices, along with a large collection of high-level mathematical functions to operate on these arrays. Numpy is immensely fast when comes to processing.

It is the fundamental package for machine learning with Python. It contains various features including these important ones:

• Random number capabilities
• Best functions
• A powerful N-dimensional array object

Besides its obvious machine learning uses, NumPy can also be used as an efficient multi-dimensional container of generic data(integer, float etc.)
But, here I’m only concerned with machine learning, so I’ll be sticking onto that, isn’t?

It’s installation is as easy as pie!

For Windows, Mac and Linux installation process is almost same!

`pip install numpy`

Since, I’ve already installed it that’s why it is highlighting this message(Requirement already satisfied).

Arrays in NumPy: NumPy’s main object is the homogeneous multidimensional array.

• It is a table of elements (usually numbers), all of the same type, indexed by a tuple of positive integers.
• In NumPy dimensions are called axes.
• NumPy’s array class is called ndarray.
`>>> import numpy as np`
`# Creating array object`
`>>> arr = np.array( [[ 1, 2, 3],[ 4, 2, 5]] )`
`# Printing type of arr object`
`>>> print("Array is of type: ", type(arr))`
`# Printing array dimensions (axes)`
`>>> print("No. of dimensions: ", arr.ndim)`
`# Printing shape of array`
`>>> print("Shape of array: ", arr.shape)`
`# Printing size (total number of elements) of array`
`>>> print("Size of array: ", arr.size)`
`# Printing type of elements in array`
`>>> print("Array stores elements of type: ", arr.dtype)`

Output :

`Array is of type:  No. of dimensions:  2Shape of array:  (2, 3)Size of array:  6Array stores elements of type:  int64`

2. Array creation: There are various ways to create arrays in NumPy.

• For example, you can create an array from a regular Python list or tuple using the array function.
• Often, the elements of an array are originally unknown, but its size is known. Hence, NumPy offers several functions to create arrays with initial placeholder content
For example: np.zeros, np.ones, np.full, np.empty, etc.
• arange: returns evenly spaced values within a given interval. step size is specified.
• linspace: returns evenly spaced values within a given interval. num no. of elements are returned.
• Reshaping array: We can use reshape method to reshape an array. Consider an array with shape (a1, a2, a3, …, aN). We can reshape and convert it into another array with shape (b1, b2, b3, …, bM). The only required condition is:
a1 x a2 x a3 … x aN = b1 x b2 x b3 … x bM . (i.e original size of array remains unchanged.)
• Flatten array: We can use flatten method to get a copy of array collapsed into one dimension.
`>>>import numpy as np`
`# Creating array from list with type float`
`>>>a = np.array([[1, 2, 4], [5, 8, 7]], dtype =` `'float')`
`>>> print ("Array created using passed list:\n", a)`
`# Creating array from tuple`
`>>> b = np.array((1` `, 3, 2))`
`>>> print ("\nArray created using passed tuple:\n", b)`
`# Creating a 3X4 array with all zeros`
`>>> c = np.zeros((3, 4))`
`>>>print("\nAn array initialized with all zeros:\n", c)`
`# Create a constant value array of complex type`
`>>> d = np.full((3, 3), 6, dtype =` `'complex')`
`>>> print("\nAn array initialized with all 6s.""Array type is complex:\n", d)`
`# Create an array with random values`
`>>> e = np.random.random((2, 2))`
`>>> print("\nA random array:\n", e)`
`# Create a sequence of integers`
`# from 0 to 30 with steps of 5`
`>>> f = np.arange(0, 30, 5)`
`>>> print("\nA sequential array with steps of 5:\n", f)`
`# Create a sequence of 10 values in range 0 to 5`
`>>> g = np.linspace(0, 5, 10)`
`>>> print("\nA sequential array with 10 values between"`
`"0 and 5:\n", g)`
`# Reshaping 3X4 array to 2X2X3 array`
`>>> arr =` `np.array([[1, 2, 3, 4],[5, 2, 4, 2],[1, 2, 0, 1]])`
`>>> newarr =` `arr.reshape(2, 2, 3)`
`>>> print("\nOriginal array:\n", arr)`
`>>> print("Reshaped array:\n", newarr)`
`# Flatten array`
`>>> arr = np.array([[1, 2, 3], [4, 5, 6]])`
`>>> flarr = arr.flatten()`
`>>> print("\nOriginal array:\n", arr)`
`>>>print("Fattened array:\n", flarr)`

Output :

`Array created using passed list: [[ 1.  2.  4.] [ 5.  8.  7.]]`
`Array created using passed tuple: [1 3 2]`
`An array initialized with all zeros: [[ 0.  0.  0.  0.] [ 0.  0.  0.  0.] [ 0.  0.  0.  0.]]`
`An array initialized with all 6s. Array type is complex: [[ 6.+0.j  6.+0.j  6.+0.j] [ 6.+0.j  6.+0.j  6.+0.j] [ 6.+0.j  6.+0.j  6.+0.j]]`
`A random array: [[ 0.46829566  0.67079389] [ 0.09079849  0.95410464]]`
`A sequential array with steps of 5: [ 0  5 10 15 20 25]`
`A sequential array with 10 values between 0 and 5: [ 0.          0.55555556  1.11111111  1.66666667  2.22222222  2.77777778  3.33333333  3.88888889  4.44444444  5.        ]`
`Original array: [[1 2 3 4] [5 2 4 2] [1 2 0 1]]Reshaped array: [[[1 2 3]  [4 5 2]]`
` [[4 2 1]  [2 0 1]]]`
`Original array: [[1 2 3] [4 5 6]]Fattened array: [1 2 3 4 5 6]`

Congratulations! You’ve done quite a lot today. Grab a cup of coffee and relax!