## Using NumPy¶

Once you've installed NumPy you can import it as a library:

In [1]:
#Import library numpy and defined them with alias np
import numpy as np


## Creating NumPy Arrays¶

### From a Python List¶

We can create an array by directly converting a list or list of lists:

In [2]:
# Creating a list with name my_list
my_list = [1,2,3]
my_list

Out[2]:
[1, 2, 3]
In [3]:
#Convert this list into array
np.array(my_list)

Out[3]:
array([1, 2, 3])

Matrix are 2D array so we can try to crate array with the help ofmatrix out

In [4]:
# Define matrix first
my_matrix = [[1,2,3],[4,5,6],[7,8,9]]
my_matrix

Out[4]:
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
In [38]:
#Convert defined matrix with the np.array function
np.array(my_matrix)

Out[38]:
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])

## Built-in Methods¶

There are lots of built-in ways to generate Arrays

### numpy.arange¶

This function returns an ndarray object containing evenly spaced values within a given range. The format of the function is as follows

numpy.arange(start, stop, step, dtype)

• Start: The start of an interval. If omitted, defaults to 0
• Stop: The end of an interval (not including this number)
• Step: Spacing between values, default is 1
• dtype: Data type of resulting ndarray. If not given, data type of input is used
In [6]:
np.arange(0,10)

Out[6]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [7]:
np.arange(0,11,2)

Out[7]:
array([ 0,  2,  4,  6,  8, 10])

### zeros and ones¶

Generate arrays of zeros or ones

In [9]:
#Create array with 0
np.zeros(3)

Out[9]:
array([0., 0., 0.])
In [10]:
np.zeros((5,5))

Out[10]:
array([[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.]])
In [11]:
# Create array with 1
np.ones(3)

Out[11]:
array([1., 1., 1.])
In [12]:
np.ones((3,3))

Out[12]:
array([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]])

### linspace¶

This function is similar to arange() function. In this function, instead of step size, the number of evenly spaced values between the interval is specified. The usage of this function is as follows −

numpy.linspace(start, stop, num, endpoint, retstep, dtype)

• start: The starting value of the sequence.
• stop: The end value of the sequence, included in the sequence if endpoint set to true.
• num: The number of evenly spaced samples to be generated. Default is 50.
• endpoint: True by default, hence the stop value is included in the sequence. If false, it is not included
• retstep: If true, returns samples and step between the consecutive numbers
• dtype: Data type of output ndarray
In [13]:
np.linspace(0,10,3)

Out[13]:
array([ 0.,  5., 10.])
In [14]:
np.linspace(0,10,50)

Out[14]:
array([ 0.        ,  0.20408163,  0.40816327,  0.6122449 ,  0.81632653,
1.02040816,  1.2244898 ,  1.42857143,  1.63265306,  1.83673469,
2.04081633,  2.24489796,  2.44897959,  2.65306122,  2.85714286,
3.06122449,  3.26530612,  3.46938776,  3.67346939,  3.87755102,
4.08163265,  4.28571429,  4.48979592,  4.69387755,  4.89795918,
5.10204082,  5.30612245,  5.51020408,  5.71428571,  5.91836735,
6.12244898,  6.32653061,  6.53061224,  6.73469388,  6.93877551,
7.14285714,  7.34693878,  7.55102041,  7.75510204,  7.95918367,
8.16326531,  8.36734694,  8.57142857,  8.7755102 ,  8.97959184,
9.18367347,  9.3877551 ,  9.59183673,  9.79591837, 10.        ])

## Random¶

Numpy also has lots of ways to create random number arrays:

### rand¶

Create an array of the given shape and populate it with random samples from a uniform distribution over [0, 1]

In [16]:
np.random.rand(2)

Out[16]:
array([0.38041172, 0.69581647])
In [17]:
np.random.rand(5,5)

Out[17]:
array([[0.1391378 , 0.06481748, 0.98038561, 0.42470571, 0.48661222],
[0.67103686, 0.18229012, 0.26071805, 0.90559128, 0.32097217],
[0.70693962, 0.41335994, 0.03467492, 0.74008155, 0.7283952 ],
[0.54449126, 0.92508253, 0.27887347, 0.26187096, 0.43980512],
[0.43045012, 0.38951795, 0.25728623, 0.42460076, 0.23841815]])

### numpy.randn¶

Return a sample (or samples) from the "standard normal" distribution. Unlike rand which is uniform:

In [19]:
np.random.randn(2)

Out[19]:
array([ 0.17417772, -0.73477371])
In [20]:
np.random.randn(5,5)

Out[20]:
array([[-1.67467891,  1.18231054,  0.09481074, -0.53381983, -1.26148369],
[-0.84688908, -1.08448611, -0.18346911,  1.55216839, -0.28783425],
[ 0.74795785, -1.120283  ,  0.02083098, -1.49669032, -1.2954995 ],
[-0.49653491, -0.30885307, -0.20996789,  0.07049668,  0.87926376],
[ 2.07987262,  0.78587006,  0.12465456, -2.04324536, -0.96852829]])

### numpy.randint¶

Return random integers from low (inclusive) to high (exclusive).

In [21]:
np.random.randint(1,100)

Out[21]:
88
In [22]:
np.random.randint(1,100,10)

Out[22]:
array([64, 76, 47, 74, 94, 30, 42, 81, 34, 80])

## Array Attributes and Methods¶

Let's discuss some useful attributes and methods or an array:

In [23]:
arr = np.arange(25)
ranarr = np.random.randint(0,50,10)

In [24]:
arr

Out[24]:
array([ 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])
In [25]:
ranarr

Out[25]:
array([18, 19,  6, 12, 14, 12,  1,  3, 42, 36])

## Reshape¶

Returns an array containing the same data with a new shape.

In [39]:
arr.reshape(5,5)

Out[39]:
array([[ 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]])

### max,min,argmax,argmin¶

These are useful methods for finding max or min values. Or to find their index locations using argmin or argmax

In [29]:
ranarr

Out[29]:
array([18, 19,  6, 12, 14, 12,  1,  3, 42, 36])
In [30]:
#gives the max value
ranarr.max()

Out[30]:
42
In [31]:
#Gives the index position of max value
ranarr.argmax()

Out[31]:
8
In [32]:
#gives the minimum value
ranarr.min()

Out[32]:
1
In [33]:
#Gives the index position of min value
ranarr.argmin()

Out[33]:
6

## Shape¶

Shape is an attribute that arrays have (not a method)

This array attribute returns a tuple consisting of array dimensions. It can also be used to resize the array.

In [35]:
# Vector
arr.shape

Out[35]:
(25,)
In [36]:
arr.reshape(1,25).shape

Out[36]:
(1, 25)

### dtype¶

An object describing the type of the elements in the array. One can create or specify dtype’s using standard Python types. Additionally NumPy provides types of its own. numpy.int32, numpy.int16, and numpy.float64 are some examples.

In [37]:
arr.dtype

Out[37]:
dtype('int32')
In [ ]:


In [ ]: