UNIT - IV

Python Numpy

 Numpy is a general-purpose array-processing package.

 It provides a high-performance multidimensional array object, and tools for working with
these arrays.
 Array in Numpy is a table of elements (usually numbers), all of the same type, indexed by a
tuple of positive integers.
 In Numpy, number of dimensions of the array is called rank of the array.
 A tuple of integers giving the size of the array along each dimension is known as shape of
the array.
 An array class in Numpy is called as ndarray.
 Elements in Numpy arrays are accessed by using square brackets and can be initialized by
using nested Python Lists.

Note: Type of array can be explicitly defined while creating the array.
Example 1:

# Python program for Creation of Arrays

import numpy as np

# Creating a rank 1 Array

arr = np.array([1, 2, 3])
print("Array with Rank 1: \n",arr)

# Creating a rank 2 Array

arr = np.array([[1, 2, 3],[4, 5, 6]])
print("Array with Rank 2: \n", arr)

# Creating an array from tuple

arr = np.array((1, 3, 2))
print("\nArray created using " "passed tuple:\n", arr)

Example 2:

1
# Python program to demonstrate indexing in numpy array
import numpy as np

# Initial Array
arr = np.array([[-1, 2, 0, 4],
[4, -0.5, 6, 0],
[2.6, 0, 7, 8],
[3, -7, 4, 2.0]])
print("Initial Array: ")
print(arr)

# Printing a range of Array with the use of slicing method

sliced_arr = arr[:2, ::2]
print ("Array with first 2 rows and"
" alternate columns(0 and 2):\n", sliced_arr)

# Printing elements at specific Indices

Index_arr = arr[[1, 1, 0, 3],
[3, 2, 1, 0]]
print ("\nElements at indices (1, 3), " "(1, 2), (0, 1), (3, 0):\n", Index_arr)

Basic Array Operations

# Python program to demonstrate basic operations on single array
import numpy as np

# Defining Array 1
a = np.array([[1, 2],
[3, 4]])

# Defining Array 2
b = np.array([[4, 3],
[2, 1]])

# Adding 1 to every element

print ("Adding 1 to every element:", a + 1)

# Subtracting 2 from each element

print ("\nSubtracting 2 from each element:", b - 2)

# sum of array elements Performing Unary operations

print ("\nSum of all array " "elements: ", a.sum())

# Adding two arrays Performing Binary operations

print ("\nArray sum:\n", a + b)

Example:

2
 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)

Example:
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)

Example:

# 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 ("Original array:\n", arr)
print("---------------")
print ("Reshaped array:\n", newarr)

Flatten array: We can use flatten method to get a copy of the array collapsed into one
dimension.
arr = np.array([[1, 2, 3], [4, 5, 6]])

3
flat_arr = arr.flatten()

print ("Original array:\n", arr)

print ("Fattened array:\n", flat_arr)

NumPy Array Indexing

Knowing the basics of NumPy array indexing is important for analyzing and manipulating
the array object. NumPy in Python offers many ways to do array indexing.
 Slicing: Just like lists in Python, NumPy arrays can be sliced. As arrays can be
multidimensional, you need to specify a slice for each dimension of the array.
 Integer array indexing: In this method, lists are passed for indexing for each
dimension. One-to-one mapping of corresponding elements is done to construct
a new arbitrary array.
 Boolean array indexing: This method is used when we want to pick elements
from the array which satisfy some condition.

# Python program to demonstrate indexing in numpy

import numpy as np

# An exemplar array
arr = np.array([[-1, 2, 0, 4],
[4, -0.5, 6, 0],
[2.6, 0, 7, 8],
[3, -7, 4, 2.0]])

# Slicing array
temp = arr[:2, ::2]
print ("Array with first 2 rows and alternate"
"columns(0 and 2):\n", temp)

# Integer array indexing example

temp = arr[[0, 1, 2, 3], [3, 2, 1, 0]]
print ("\nElements at indices (0, 3), (1, 2), (2, 1),"
"(3, 0):\n", temp)

# boolean array indexing example

cond = arr > 0 # cond is a boolean array
temp = arr[cond]
print ("\nElements greater than 0:\n", temp)

NumPy Basic Operations

The Plethora of built-in arithmetic functions is provided in Python NumPy.

4
Operations on a single NumPy array
We can use overloaded arithmetic operators to do element-wise operations on the array to
create a new array. In the case of +=, -=, *= operators, the existing array is modified.

# Python program to demonstrate basic operations on single array

import numpy as np

a = np.array([1, 2, 5, 3])

# add 1 to every element

print ("Adding 1 to every element:", a+1)

# subtract 3 from each element

print ("Subtracting 3 from each element:", a-3)

# multiply each element by 10

print ("Multiplying each element by 10:", a*10)

# square each element

print ("Squaring each element:", a**2)

# modify existing array

a *= 2
print ("Doubled each element of original array:", a)

# transpose of array
a = np.array([[1, 2, 3], [3, 4, 5], [9, 6, 0]])

print ("\nOriginal array:\n", a)

print ("Transpose of array:\n", a.T)

NumPy – Unary Operators

Many unary operations are provided as a method of ndarray class. This includes sum, min,
max, etc. These functions can also be applied row-wise or column-wise by setting an axis
parameter.

# Python program to demonstrate unary operators in numpy

import numpy as np

arr = np.array([[1, 5, 6],

5
 [4, 7, 2],
[3, 1, 9]])

# maximum element of array

print ("Largest element is:", arr.max())
print ("Row-wise maximum elements:",
arr.max(axis = 1))

# minimum element of array

print ("Column-wise minimum elements:",
arr.min(axis = 0))

# sum of array elements

print ("Sum of all array elements:",
arr.sum())

# cumulative sum along each row

print ("Cumulative sum along each row:\n",
arr.cumsum(axis = 1))

NumPy – Binary Operators

These operations apply to the array elementwise and a new array is created. You can use all
basic arithmetic operators like +, -, /, etc. In the case of +=, -=, = operators, the existing
array is modified.

# Python program to demonstrate binary operators in Numpy

import numpy as np

a = np.array([[1, 2],
[3, 4]])
b = np.array([[4, 3],
[2, 1]])

# add arrays
print ("Array sum:\n", a + b)

# multiply arrays (elementwise multiplication)

print ("Array multiplication:\n", a*b)

# matrix multiplication
print ("Matrix multiplication:\n", a.dot(b))

NumPy Sorting Arrays

There is a simple np.sort() method for sorting Python NumPy arrays. Let’s explore it a bit.

6
# Python program to demonstrate sorting in numpy
import numpy as np

a = np.array([[1, 4, 2],
[3, 4, 6],
[0, -1, 5]])

# sorted array
print ("Array elements in sorted order:\n",
np.sort(a, axis = None))

# sort array row-wise

print ("Row-wise sorted array:\n",
np.sort(a, axis = 1))

# specify sort algorithm

print ("Column wise sort by applying merge-sort:\n",
np.sort(a, axis = 0, kind = 'mergesort'))

# Example to show sorting of structured array

# set alias names for dtypes
dtypes = [('name', 'S10'), ('grad_year', int), ('cgpa', float)]

# Values to be put in array

values = [('Hrithik', 2009, 8.5), ('Ajay', 2008, 8.7),
('Pankaj', 2008, 7.9), ('Aakash', 2009, 9.0)]

# Creating array
arr = np.array(values, dtype = dtypes)
print ("\nArray sorted by names:\n",
np.sort(arr, order = 'name'))

print ("Array sorted by graduation year and then cgpa:\n",

np.sort(arr, order = ['grad_year', 'cgpa']))

Example:

# dtype parameter
import numpy as np
a = np.array([1, 2, 3], dtype = complex)
print a

# this resizes the ndarray

import numpy as np

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

import numpy as np
a = np.array([[1,2,3],[4,5,6]])
b = a.reshape(3,2)
print b

# an array of evenly spaced numbers

import numpy as np
a = np.arange(24)
print a

# this is one dimensional array

import numpy as np
a = np.arange(24)
a.ndim

# now reshape it
b = a.reshape(2,4,3)
print b

# convert list to ndarray

import numpy as np

x = [1,2,3]
a = np.asarray(x)
print a

# dtype is set
import numpy as np

x = [1,2,3]
a = np.asarray(x, dtype = float)
print a

# ndarray from tuple

import numpy as np

x = (1,2,3)
a = np.asarray(x)
print a

8
# ndarray from list of tuples
import numpy as np

x = [(1,2,3),(4,5)]
a = np.asarray(x)
print a

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)

The constructor takes the following parameters.

Sr.No. Parameter & Description

1 start
The start of an interval. If omitted, defaults to 0

2 stop
The end of an interval (not including this number)

3 step
Spacing between values, default is 1

dtype
4 Data type of resulting ndarray. If not given, data type of input is
used
# start and stop parameters set
import numpy as np
x = np.arange(10,20,2)
print x

import numpy as np
a = np.arange(10)
s = slice(2,7,2)
print a[s]

import numpy as np
a = np.arange(10)

9
b = a[2:7:2]
print b

# slice items starting from index

import numpy as np
a = np.arange(10)
print a[2:]

# slice items between indexes

import numpy as np
a = np.arange(10)
print a[2:5]

import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print a

# slice items starting from index

print 'Now we will slice the array from the index a[1:]'
print a[1:]

import numpy as np
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])

print 'Our array is:'

print x
print '\n'

# slicing
z = x[1:4,1:3]

print 'After slicing, our array becomes:'

print z
print '\n'

# using advanced index for column

y = x[1:4,[1,2]]

print 'Slicing using advanced index for column:'

print y

NumPy – Broadcasting

10
The term broadcasting refers to the ability of NumPy to treat arrays of different shapes
during arithmetic operations. Arithmetic operations on arrays are usually done on
corresponding elements.
import numpy as np

a = np.array([1,2,3,4])
b = np.array([10,20,30,40])
c=a*b
print c

import numpy as np
a = np.array([[0.0,0.0,0.0],[10.0,10.0,10.0],[20.0,20.0,20.0],[30.0,30.0,30.0]])
b = np.array([1.0,2.0,3.0])

print 'First array:'

print a
print '\n'

print 'Second array:'

print b
print '\n'

print 'First Array + Second Array'

print a + b

Example
import numpy as np

# create 1-D array

array1 = np.array([1, 2, 3])

# create 2-D array

array2 = np.array([[1], [2], [3]])

# add arrays of different dimension

# size of array1 expands to match with array2
sum = array1 + array2

print(sum)

11
Compatibility Rules for Broadcasting

Broadcasting only works with compatible arrays. NumPy compares a set of array
dimensions from right to left.

Every set of dimensions must be compatible with the arrays to be broadcastable. A

set of dimension lengths is compatible when

 one of them has a length of 1 or

 they are equal

Let's see an example.

array1 = shape(6, 7)
array2 = shape(6, 1)
 Here, array1 and array2 are arrays with different
dimensions (6,7) and (6,1) respectively.
 The dimension length 7 and 1 are compatible because one of them is 1.
 Similarly, 6 and 6 are compatible since they are the same.
 As both sets of dimensions are compatible, the arrays are broadcastable.

Examples of Broadcastable Shapes

Now, we'll see the list of broadcastable and non-broadcastable shapes.

Broadcastable Shapes
 (6, 7) and (6, 7)

 (6, 7) and (6, 1)

 (6, 7) and (7, )

Two arrays need not have the same number of dimensions to be broadcastable.

The last set of shapes is broadcastable because the right-most dimensions are
both 7.
Non-Broadcastable Shapes
 (6, 7) and (7, 6)

12
  (6, 7) and (6, )

The last set of shapes is not broadcastable because the right-most dimensions are
not the same.

Comparision:
import numpy as np
x = np.array([1, 2, 3, 4, 5])
print(x<3)
print(x<=3)
print(x!=3)
print(x==3)
print(2*x)
print(x**2)
print((2 * x) == (x ** 2))

Example:
rng = np.random.RandomState(0)
x = rng.randint(10, size=(3, 4))
print(x)
print(x<6)
np.less(x, 6)

Comparison operators and their equivalent ufunc is shown here

Operator Equivalent ufunc
== np.equal
!= np.not_equal
< np.less
<= np.less_equal
> np.greater
>= np.greater_equal

Example:

import numpy as np
13
x = np.array([[1, 4, 2],
[3, 4, 6],
[0, -1, 5]])
#x = np.array([1, 2, 3, 4, 5])
print(np.count_nonzero(x > 6))
print(np.sum(x < 6))
# how many values less than 6 in each row?
print(np.sum(x < 6, axis=1)) #row wise count
# are there any values greater than 8?
print(np.any(x > 4))
# are all values less than 10?
print(np.all(x < 10))
# are all values equal to 6?
print(np.all(x == 6))
# are all values in each row less than 8?
print(np.all(x < 8, axis=1))
print(x[x < 5])

Now to select these values from the array, we can simply index on this Boolean array;
this is known as a masking operation:

Boolean Logic
A = np.array([1, 0, 1, 0, 1, 0], dtype=bool)
B = np.array([1, 1, 1, 0, 1, 1], dtype=bool)
print(A | B)
x = np.arange(10)
print((x > 4) & (x < 8))

Select Multiple Elements Using NumPy Fancy Indexing

import numpy as np

# create a numpy array

array1 = np.array([1, 2, 3, 4, 5, 6, 7, 8])

# select elements at index 1, 2, 5, 7

select_elements = array1[[1, 2, 5, 7]]

14
print(select_elements)

Example

import numpy as np

array1 = np.array([1, 2, 3, 4, 5, 6, 7, 8])

# select a single element

simple_indexing = array1[3]

print("Simple Indexing:",simple_indexing) # 4

# select multiple elements

fancy_indexing = array1[[1, 2, 5, 7]]

print("Fancy Indexing:",fancy_indexing) # [2 3 6 8]

Fancy Indexing for Sorting NumPy Array

import numpy as np

array1 = np.array([3, 2, 6, 1, 8, 5, 7, 4])

# sort array1 using fancy indexing

sorted_array = array1[np.argsort(array1)]

print(sorted_array)

Example

#We could also use fancy indexing to sort the array in descending order.

import numpy as np
array1 = np.array([3, 2, 6, 1, 8, 5, 7, 4])

# sort array1 using fancy indexing in descending order

sorted_array = array1[np.argsort(-array1)]
print(sorted_array)
15
Fancy Indexing to Assign New Values to Specific Elements

We can also assign new values to specific elements of a NumPy array using fancy
indexing. For example,

import numpy as np

array1 = np.array([3, 2, 6, 1, 8, 5, 7, 4])

# create a list of indices to assign new values

indices = [1, 3, 6]
# create a new array of values to assign
new_values = [10, 20, 30]

# use fancy indexing to assign new values to specific elements

array1[indices] = new_values

print(array1)

Fancy Indexing on N-d Arrays

We can also use fancy indexing on multi-dimensional arrays.

import numpy as np

# create a 2D array
array1 = np.array([[1, 3, 5],
[11, 7, 9],
[13, 18, 29]])

# create an array of row indices

row_indices = np.array([0, 2])

# use fancy indexing to select specific rows

selected_rows = array1[row_indices, :]

print(selected_rows)

Structured arrays

16
Structured arrays are ndarrays whose datatype is a composition of simpler datatypes
organized as a sequence of named fields. For example,

x = np.array([('Rex', 9, 81.0), ('Fido', 3, 27.0)],dtype=[('name', 'U10'), ('age', 'i4'), ('weight',

'f4')])
print(x)

Here x is a one-dimensional array of length two whose datatype is a structure with three
fields: 1. A string of length 10 or less named ‘name’, 2. a 32-bit integer named ‘age’, and 3. a
32-bit float named ‘weight’.

x = np.array([(1, 2, 3), (4, 5, 6)], dtype='i8, f4, f8')

x[1] = (7, 8, 9)
print(x)
Example

import numpy as np
a = np.array([('Sana', 2, 21.0), ('Mansi', 7, 29.0)],
dtype=[('name', (np.str_, 10)), ('age', np.int32), ('weight', np.float64)])

# Sorting according to the name

b = np.sort(a, order='name')
print('Sorting according to the name', b)

# Sorting according to the age

b = np.sort(a, order='age')
print('\nSorting according to the age', b)

max_age = np.max(a['age'])
min_age = np.min(a['age'])

print("Max age = ",max_age)

print("Min age = ", min_age)

17
Concatenating Structured Array

import numpy as np
a = np.array([('Sana', 2, 21.0), ('Mansi', 7, 29.0)],
dtype=[('name', (np.str_, 10)), ('age', np.int32), ('weight', np.float64)])

b = np.array([('Ayushi', 5, 30.0)], dtype=a.dtype)

c = np.concatenate((a, b))
print(c)

Reshaping a Structured Array

import numpy as np
a = np.array([('Sana', 2, 21.0), ('Mansi', 7, 29.0)],
dtype=[('name', (np.str_, 10)), ('age', np.int32), ('weight', np.float64)])
reshaped_a = np.reshape(a, (2, 1))
print(reshaped_a)

18