# Numpy in Python

Python Numpy: In this tutorial, we are going to learn about the Numpy in Python programming language which is an array processing package. Here, we will also learn to install Numpy, arrays, methods, etc.
Submitted by Sapna Deraje Radhakrishna, on December 26, 2019

## What is Numpy in Python?

Numpy is an array processing package which provides high-performance multidimensional array object and utilities to work with arrays. It is a basic package for scientific computation with python. It is a linear algebra library and is very important for data science with python since almost all of the libraries in the pyData ecosystem rely on Numpy as one of their main building blocks. It is incredibly fast, as it has bindings to C.

Some of the many features, provided by numpy are as always,

1. N-dimensional array object
3. Utilities for integrating with C / C++
4. Useful linear algebra and random number capabilities

### Installing Numpy

1) Using pip

```    pip install numpy
```

Installing output

```pip install numpy
Collecting numpy
100% |████████████████████████████████| 15.1MB 1.3MB/s
Installing collected packages: numpy
Successfully installed numpy-1.17.4
```

2) Using Anaconda

```    conda install numpy
```

### Arrays in Numpy

Numpy's main object is the homogeneous multidimensional array. Numpy arrays are two types: vectors and matrices. vectors are strictly 1-d arrays and matrices are 2-d.

In Numpy dimensions are known as axes. The number of axes is rank. The below examples lists the most important attributes of a ndarray object.

Example:

```# importing package
import numpy as np

# creating array
arr = np.array([[11,12,13],[14,15,16]])

print("Array is of type {}".format(type(arr)))
print("No. of dimensions {}".format(arr.ndim))
print("shape of array:{}".format(arr.shape))
print("size of array:{}".format(arr.size))
print("type of elements in the array:{}".format(arr.dtype))
```

Output

```Array is of type <class 'numpy.ndarray'>
No. of dimensions 2
shape of array:(2, 3)
size of array:6
type of elements in the array:int64
```

### Creating a numpy array

Creating a numpy array is possible in multiple ways. For instance, a list or a tuple can be cast to a numpy array using the. array() method (as explained in the above example). The array transforms a sequence of the sequence into 2-d arrays, sequences of sequences into a 3-d array and so on.

To create sequences of numbers, NumPy provides a function called arange that returns arrays instead of lists.

Syntax:

```    # returns evenly spaced values within a given interval.
arange([start,] stop [,step], dtype=None)
```

Example:

```x = np.arange(10,30,5)
print(x)
# Ouput: [10 15 20 25]
```

The function zeros create an array full of zeros, the function ones create an array full of ones, and the function empty creates an array whose initial content is random and depends on the state of the memory. By default, the dtype of the created array is float64.

Example:

```# importing package
import numpy as np

x = np.zeros((3,4))
print("np.zeros((3,4))...")
print(x)

x = np.ones((3,4))
print("np.ones((3,4))...")
print(x)

x = np.empty((3,4))
print("np.empty((3,4))...")
print(x)

x = np.empty((1,4))
print("np.empty((1,4))...")
print(x)
```

Output

```np.zeros((3,4))...
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
np.ones((3,4))...
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
np.empty((3,4))...
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
np.empty((1,4))...
[[1.63892563e-316 0.00000000e+000 2.11026305e-312 2.56761491e-312]]
```

### Numpy functions

Some more function available with NumPy to create an array are,

1) linspace()

It returns an evenly spaced numbers over a specified interval.

Syntax:

```    linspace(start, stop, num=50, endpoint=True, restep=False, dtype=None)
```

Example:

```# importing package
import numpy as np

x = np.linspace(1,3,num=10)
print(x)
```

Output

```[1.         1.22222222 1.44444444 1.66666667 1.88888889 2.11111111
2.33333333 2.55555556 2.77777778 3.        ]
```

2) eye()

It returns a 2-D array with ones on the diagonal and zeros elsewhere.

Syntax:

```    eye(N, M=None, k=0, dtype=<class 'float'>, order='C')
```

Example:

```# importing package
import numpy as np

x = np.eye(4)
print(x)
```

Output

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

3) random()

It creates an array with random numbers

Example:

```# importing package
import numpy as np

x = np.random.rand(5)
print("np.random.rand(5)...")
print(x)

x = np.random.rand(5,1)
print("np.random.rand(5,1)...")
print(x)

x = np.random.rand(5,1,3)
print("np.random.rand(5,1,3)...")
print(x)

# returns a random number
x = np.random.randn()
print("np.random.randn()...")
print(x)

# returns a 2-D array with random numbers
x = np.random.randn(2,3)
print("np.random.randn(2,3)...")
print(x)

x = np.random.randint(3)
print("np.random.randint(3)...")
print(x)

# returns a random number in between low and high
x = np.random.randint(3,100)
print("np.random.randint(3,100)...")
print(x)

# returns an array of random numbers of length 34
x = np.random.randint(3,100,34)
print("np.random.randint(3,100,34)...")
print(x)
```

Output

```np.random.rand(5)...[0.87417146 0.77399086 0.40012698 0.37192848 0.98260636]
np.random.rand(5,1)...
[[0.712829  ]
[0.65959462]
[0.41553044]
[0.30583293]
[0.83997539]]
np.random.rand(5,1,3)...
[[[0.75920149 0.54824968 0.0547891 ]]

[[0.70911911 0.16475541 0.5350475 ]]

[[0.74052103 0.4782701  0.2682752 ]]
[[0.76906319 0.02881364 0.83366651]]

[[0.79607073 0.91568043 0.7238144 ]]]
np.random.randn()...
-0.6793254693909823
np.random.randn(2,3)...
[[ 0.66683143  0.44936287 -0.41531392]
[ 1.86320357  0.76638331 -1.92146833]]
np.random.randint(3)...
1
np.random.randint(3,100)...
53
np.random.randint(3,100,34)...
[43 92 76 39 78 83 89 87 96 59 32 74 31 77 56 53 18 45 78 21 46 10 25 86
64 29 49  4 18 19 90 17 62 29]
```

4) Reshape method (shape manipulation)

An array has a shape given by the number of elements along each axis,

```# importing package
import numpy as np

x = np.floor(10*np.random.random((3,4)))
print(x)

print(x.shape)
```

Output

```[[0. 2. 9. 4.]
[0. 4. 1. 7.]
[9. 7. 6. 2.]]
(3, 4)
```

The shape of an array can be changes with various commands. However, the shape commands return all modified arrays but do not change the original array.

```# importing package
import numpy as np

x = np.floor(10*np.random.random((3,4)))
print(x)

# returns the array, flattened
print("x.ravel()...")
print(x.ravel())

# returns the array with modified shape
print("x.reshape(6,2)...")
print(x.reshape(6,2))

# returns the array , transposed
print("x.T...")
print(x.T)

print("x.T.shape...")
print(x.T.shape)

print("x.shape...")
print(x.shape)
```

Output

```[[3. 1. 0. 6.] [3. 1. 2. 4.]
[7. 0. 0. 1.]]
x.ravel()...
[3. 1. 0. 6. 3. 1. 2. 4. 7. 0. 0. 1.]
x.reshape(6,2)...
[[3. 1.]
[0. 6.]
[3. 1.]
[2. 4.]
[7. 0.]
[0. 1.]]
x.T...
[[3. 3. 7.] [1. 1. 0.]
[0. 2. 0.]
[6. 4. 1.]]
x.T.shape...
(4, 3)
x.shape...
(3, 4)
```

```# importing package
import numpy as np

x = np.floor(10*np.random.random((3,4)))
print(x)

#Return the maximum value in an array
print("x.max():", x.max())

# Return the minimum value in a array
print("x.min():", x.min())

# Return the index of max value in an array
print("x.argmax():", x.argmax())

# Return the index of min value in an array
print("x.argmin():", x.argmin())
```

Output

```[[4. 0. 5. 2.] [8. 5. 9. 7.]
[9. 3. 5. 5.]]
x.max(): 9.0
x.min(): 0.0
x.argmax(): 6
x.argmin(): 1
```

Preparation