# Introduction to Numpy for scientific computing

This tutorial gives a brief description of scientific computing using numpy by introducing arrays, methods, attributes, random numbers, indexing, broadcasting, operations and functions

Numpy is a numerical processing library in Python that is capable of efficiently handling large datasets. It is the building block of many libraries such as Pandas, SciPy, Scikit-learn, etc. It is incredibly fast given its bindings to C libraries.

In this post, we will focus only on the basics as the capabilities and possibilities with Numpy are immense and it is not possible to cover everything in one post. For quickly jumping between different topics, use the “contents” that has been linked to the topics by hyperlinks.

## Similar posts

## Create numpy arrays

### 1-D array

```
import numpy as np #we give an alias to numpy
mylist = [1, 2, 3] #create a list
myarray = np.array(mylist) #convert list to array
```

### Higher dimensional arrays (or matrix)

```
my_matrix = [[1,2,3],[4,5,6],[7,8,9]]
my_np_matrix = np.array(my_matrix)
print(my_np_matrix)
```

This returns (=>):

```
[[1 2 3]
[4 5 6]
[7 8 9]]
```

## Methods and attributes in numpy

We can access the methods or attributes in numpy by using the “.”.

```
print(my_np_matrix.shape)
```

=>

```
(3, 3)
```

```
print(my_np_matrix.mean())
```

=>

```
5.0
```

### reshape

```
arr = np.arange(25)
print(arr)
reshaped_arr = arr.reshape(5,5)
print(reshaped_arr)
```

We use the same data and shape it into new dimension =>

```
[ 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]
[[ 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]]
```

Also, keep in mind that we cannot use any shape we want here. Since, the original dataset had only 25 elements, we can reshape it into `5 x 5`

, `1 x 25`

, `25 x 1`

, etc.

### minimum, maximum and its indices

```
ranarr = np.random.randint(34, 68, 10)
print(ranarr)
print(ranarr.max())
print(ranarr.argmax())
print(ranarr.min())
print(ranarr.argmin())
```

=>

```
[40 37 36 62 44 54 54 67 54 63]
67
7
36
2
```

### datatype with `dtype`

```
print(ranarr.dtype)
```

=>

```
int64
```

## Built-in Methods in numpy

### arange

```
a = np.arange(0,10)
print(a)
b = np.arange(0,11,2)
print(b)
```

=>

```
[0 1 2 3 4 5 6 7 8 9]
[ 0 2 4 6 8 10]
```

### zeros and ones

```
twod_zeros = np.zeros((5,5))
print(twod_zeros)
twod_ones = np.ones((3,3)) #make two dimensional array of ones
print(twod_ones)
```

=>

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

```
twod_ones_new = twod_ones * 100
print(twod_ones_new)
```

=>

```
[[100. 100. 100.]
[100. 100. 100.]
[100. 100. 100.]]
```

`linspace`

for evenly spaced numbers

```
Z = np.linspace(0,5,20)
print(Z)
```

This gives 20 linearly spaced numbers between 0 and 5.

=>

```
[0. 0.26315789 0.52631579 0.78947368 1.05263158 1.31578947
1.57894737 1.84210526 2.10526316 2.36842105 2.63157895 2.89473684
3.15789474 3.42105263 3.68421053 3.94736842 4.21052632 4.47368421
4.73684211 5. ]
```

### identity matrix with `eye`

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

=>

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

## Random numbers in Numpy

### From uniform distribution

```
myrand = np.random.rand(2)
print(myrand)
```

This creates an array of the specified shape and populates it with random samples from a uniform distribution over [0, 1).

=>

```
[0.8300824 0.93838919]
```

```
myrand2 = np.random.rand(5,5)
print(myrand2)
```

=>

```
[[0.56931238 0.0130365 0.49126232 0.87114911 0.76042729]
[0.09251311 0.82855503 0.63039485 0.97381338 0.01540617]
[0.97649667 0.30297094 0.26201115 0.64828968 0.44611475]
[0.71639265 0.93906588 0.31467679 0.82751456 0.13620669]
[0.04310447 0.22531851 0.69068734 0.43045271 0.44482673]]
```

### From standard normal distribution

```
mynrand = np.random.randn(2)
print(mynrand)
```

=>

```
[-0.40174504 0.00292135]
```

### Random integers

```
myrandint = np.random.randint(1,100)
print(myrandint)
print(np.random.randint(1,100,10))
```

=>

```
82
[94 80 31 18 62 69 26 71 64 93]
```

### Set the random state with `seed`

```
np.random.seed(12)
print(np.random.rand(4))
```

You should get the same exact output as me if you use the same seed as above. =>

```
[0.15416284 0.7400497 0.26331502 0.53373939]
```

## Numpy Indexing

Let us first create a simple array to start with:

```
arr = np.arange(0,11)
print(arr)
```

=>

```
[ 0 1 2 3 4 5 6 7 8 9 10]
```

To get a value at an index or in a range of indexes:

```
print(arr[8])
#Get values in a range
print(arr[0:5])
```

=>

```
8
[0 1 2 3 4]
```

### Broadcating values at a range of indexes

Unlike Python lists, with NumPy arrays, one can broadcast a single value across a larger set of values.

```
arr[0:5]=120
print(arr)
print(arr **2)
```

=>

```
[120 120 120 120 120 5 6 7 8 9 10]
[14400 14400 14400 14400 14400 25 36 49 64 81 100]
```

We can also use this design to extract the slice of an array:

```
print(arr)
#Important notes on Slices
slice_of_arr = arr[0:6]
#Show slice
print(slice_of_arr)
```

=>

```
[120 120 120 120 120 5 6 7 8 9 10]
[120 120 120 120 120 5]
```

Another good point about slicing in Numpy is that the data is not being copied but still pointing to the original array. This avoids memory problems.

```
arr = np.arange(0,11)
print(arr)
#Change Slice
slice_of_arr = arr[0:6]
slice_of_arr[:]=99
#Show Slice again
print(slice_of_arr)
print(arr)
```

=>

```
[ 0 1 2 3 4 5 6 7 8 9 10]
[99 99 99 99 99 99]
[99 99 99 99 99 99 6 7 8 9 10]
```

We can avoid this using the `copy`

method.

```
arr = np.arange(0,11)
print(arr)
#To get a copy, need to be explicit
arr_copy = arr.copy()
print(arr_copy)
#Change Slice
slice_of_arr = arr_copy[0:6]
slice_of_arr[:]=99
#Show Slice again
print(slice_of_arr)
print(arr)
print(arr_copy)
```

=>

```
[ 0 1 2 3 4 5 6 7 8 9 10]
[ 0 1 2 3 4 5 6 7 8 9 10]
[99 99 99 99 99 99]
[ 0 1 2 3 4 5 6 7 8 9 10]
[99 99 99 99 99 99 6 7 8 9 10]
```

### Indexing a 2D array

```
arr_2d = np.array(([5,10,15],[20,25,30],[35,40,45]))
#Show
print(arr_2d)
```

=>

```
[[ 5 10 15]
[20 25 30]
[35 40 45]]
```

```
# Getting individual element value
print(arr_2d[1][0]) # Format is arr_2d[row][col] or arr_2d[row,col]
# or
print(arr_2d[1,0])
print(arr_2d[:2,1:])
print(arr_2d[:2,1:]) #(2,2) from top right corner
```

=>

```
20
20
[[10 15]
[25 30]]
```

### Conditional Selection

```
arr = np.arange(1,11)
print(arr)
print(arr > 5)
```

=>

```
[ 1 2 3 4 5 6 7 8 9 10]
[False False False False False True True True True True]
```

```
print(arr[arr>5])
print(arr[(arr>5) & (arr<9)])
```

=>

```
[ 6 7 8 9 10]
[6 7 8]
```

## Numpy Operations

```
arr = np.arange(0,10)
print(arr)
```

=>

```
[0 1 2 3 4 5 6 7 8 9]
```

### Simple arithmetics

```
print(arr + arr)
print(arr * arr)
print(arr**3)
```

=>

```
[ 0 2 4 6 8 10 12 14 16 18]
[ 0 1 4 9 16 25 36 49 64 81]
[ 0 1 8 27 64 125 216 343 512 729]
```

### Universal array functions

Check the numpy documentation for the list of all the universal functions: ufuncs in numpy

```
# Taking Square Roots
print(np.sqrt(arr))
# Trigonometric Functions like sine
print(np.sin(arr))
```

=>

```
[0. 1. 1.41421356 1.73205081 2. 2.23606798
2.44948974 2.64575131 2.82842712 3. ]
[ 0. 0.84147098 0.90929743 0.14112001 -0.7568025 -0.95892427
-0.2794155 0.6569866 0.98935825 0.41211849]
```

## Dealing with different axes

In numpy array, axis 0 (zero) is the vertical axis (rows), and axis 1 is the horizonal axis (columns).

```
arr_2d = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
print(arr_2d)
```

=>

```
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
```

```
print(arr_2d.sum(axis=0)) #returns the sum across rows
print(arr_2d.sum(axis=1)) #returns the sum across columns
```

=>

```
[15 18 21 24]
[10 26 42]
```

Next, in the series of Python tutorials is “Pandas”.

## References

- Photo by Karl Magnuson on Unsplash

#### Disclaimer of liability

The information provided by the Earth Inversion is made available for educational purposes only.

Whilst we endeavor to keep the information up-to-date and correct. Earth Inversion makes no representations or warranties of any kind, express or implied about the completeness, accuracy, reliability, suitability or availability with respect to the website or the information, products, services or related graphics content on the website for any purpose.

UNDER NO CIRCUMSTANCE SHALL WE HAVE ANY LIABILITY TO YOU FOR ANY LOSS OR DAMAGE OF ANY KIND INCURRED AS A RESULT OF THE USE OF THE SITE OR RELIANCE ON ANY INFORMATION PROVIDED ON THE SITE. ANY RELIANCE YOU PLACED ON SUCH MATERIAL IS THEREFORE STRICTLY AT YOUR OWN RISK.

## Leave a comment