Unit III Python

Unit – III Python for Data Science
UNIT III: (10 hours) NumPy Basics: Arrays and Vectorized Computation- The
NumPy ndarray- Creating ndarrays Data Types for ndarrays- Arithmetic with
NumPy Arrays- Basic Indexing and Slicing - Boolean Indexing-Transposing Arrays
and Swapping Axes. Universal Functions: Fast Element-Wise Array Functions-
Mathematical and Statistical Methods-Sorting- Unique and Other Set Logic
NumPy:
NumPy, short for Numerical Python, is one of the most important
foundational packages for numerical computing in Python. it is designed for
efficiency on large arrays of data. There are a number of reasons for this:
 ndarray, an efficient multidimensional array providing fast array-oriented
arithmetic operations and flexible broadcasting capabilities.
 Mathematical functions for fast operations on entire arrays of data without
having to write loops.
 Tools for reading/writing array data to disk and working with memory-
mapped files.
 Linear algebra, random number generation, and Fourier transform
capabilities.
 A C API for connecting NumPy with libraries written in C, C++, or FORTRAN.
One of the reasons NumPy is so important for numerical computations in
Python is because it is designed for efficiency on large arrays of data. There are a
number of reasons for this:
NumPy internally stores data in a contiguous block of memory,
independent of other built-in Python objects. NumPy’s library of algorithms
written in the C language can operate on this memory without any type checking
NumPy arrays also use much less memory than built-in Python sequences.
NumPy operations perform complex computations on entire arrays without
the need for Python for loops.
import numpy as np
my_arr = np.arange(1000000)
my_list = list(range(1000000))
B V Raju College Page 1

Now let’s multiply each sequence by 2:

%time for _ in range(10): my_arr2 = my_arr * 2
CPU times: user 20 ms, sys: 8 ms, total: 28 ms
Wall time: 26.5 ms
%time for _ in range(10): my_list2 = [x * 2 for x in my_list]

CPU times: user 408 ms, sys: 64 ms, total: 472 ms
Wall time: 473 ms
NumPy-based algorithms are generally 10 to 100 times faster (or more)
than their pure Python counterparts and use significantly less memory.
Difference Between List and Array:
List Array
List can have elements of different data All elements of an array are of same
types for example, [1,3.4, ‘hello’, ‘a@’] data type for example, an array of floats
may be: [1.2, 5.4, 2.7]
Lists do not support element wise Arrays support element wise

operations, for example, addition, operations. For example, if A1 is an
multiplication, etc. because elements array, it is possible to say A1/3 to divide
may not be of same type each element of the array by 3.
Lists can contain objects of different NumPy array takes up less space in
datatype that Python must store the memory as compared to a list because
type information for every element arrays do not require to store datatype
along with its element value. Thus lists of each element separately.
take more space in memory and are
less efficient.
List is a part of core Python. Array (ndarray) is a part of NumPy

library.

THE NUMPY NDARRAY: A MULTIDIMENSIONAL ARRAY OBJECT
One of the key features of NumPy is its N-dimensional array object, or

ndarray, which is a fast, flexible container for large datasets in Python. Arrays
enable us to perform mathematical operations on whole blocks of data using
similar syntax to the equivalent operations between scalar elements.
import numpy as np
# Generate some random data
data = np.random.randn(2, 3)
print(data)
data=data * 10
print(data)
data= data + data

print(data)
output:
[[ 1.02769038 -0.45400781 -1.09134785]
[-0.74483404 -0.89984109 -0.04883344]]
[[ 10.27690378 -4.54007811 -10.91347855]

[ -7.44834037 -8.99841092 -0.48833438]]
[[ 20.55380756 -9.08015622 -21.82695709]

[-14.89668073 -17.99682185 -0.97666877]]

In the first example, all of the elements have been multiplied by 10. In the
second, the corresponding values in each “cell” in the array have been added to
each other.
An ndarray is a generic multidimensional container for homogeneous data;
that is, all of the elements must be the same type.
Every array has a shape, a tuple indicating the size of each dimension, and
a dtype, an object describing the data type of the array:
print(data.shape)
(2, 3)
print(data.dtype)
dtype('float64')
Arrays:
Example:
import numpy as np
a = np.arange(15).reshape(3, 5)
print(“array is”,a)
print("array size is",a.shape)
print("array dimensions",a.ndim)
print("itewm size is",a.itemsize)
print("type of array",type(a))
O/P:
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
array size is (3, 5)

array dimensions 2
item size is 4
type of array <class 'numpy.ndarray'>
CREATING NDARRAYS
The easiest way to create an array is to use the array function. This accepts
any sequence-like object (including other arrays) and produces a new NumPy
array containing the passed data.
Exam
import numpy as np
a = np.array([2,3,4])
print("array is",a)
print("data type", a.dtype)
b = np.array([1.2, 3.5, 5.1])

print("array b",b.dtype)
O/p:
array is [2 3 4]
data type int32
array b float64
Array transforms sequences of sequences into two-dimensional arrays,

sequences of sequences of sequences into three-dimensional arrays, and so on.
Example:
import numpy as np
b = np.array([(1.5,2,3), (4,5,6)])
print("two dim array",b)

O/P:
two dim array [[1.5 2 3 ]
[4 5 6 ]]
The type of the array can also be explicitly specified at creation time:
Example:
import numpy as np
c = np.array( [ [1,2], [3,4] ], dtype=complex )
print("complex array",c)
O/P:
complex array [[1.+0.j 2.+0.j]
[3.+0.j 4.+0.j]]
To create sequences of numbers, NumPy provides a function analogous to

range that returns arrays instead of lists.
np.arange( 10, 30, 5 )
array([10, 15, 20, 25])
np.arange( 0, 2, 0.3 ) # it accepts float arguments

array([ 0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])
The function zeros creates an array full of zeros, the function ones creates
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:

import numpy as np
a=np.zeros( (3,4) )
print("array a is",a)
b=np.ones( (2,3,4), dtype=np.int16 )
print("array b is",b)
O/P:
array a is
[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
array b is
[[[1 1 1 1]
[1 1 1 1]
[1 1 1 1]]
[[1 1 1 1]
[1 1 1 1]
[1 1 1 1]]]
Function Description
Convert input data (list, tuple, array, or other sequence type) to an

array ndarray either by inferring a dtype or explicitly specifying a dtype;
copies the input data by default
Convert input to ndarray, but do not copy if the input is already an

asarray
ndarray

arange Like the built-in range but returns an ndarray instead of a list
Produce an array of all 1s with the given shape and

ones,
dtype; ones_like takes another array and produces a ones array of the
ones_like
same shape and dtype
zeros,
Like ones and ones_like but producing arrays of 0s instead
zeros_like
empty, Create new arrays by allocating new memory, but do not populate
empty_like with any values like ones and zeros
Produce an array of the given shape and dtype with all values set to
full,
the indicated “fill value” full_like takes another array and produces a
full_like
filled array of the same shape and dtype
eye, Create a square N × N identity matrix (1s on the diagonal and 0s

identity elsewhere)
Table 4-1. Array creation functions
Data Types for ndarrays:

NumPy supports a much greater variety of numerical types than Python
does. The primitive types supported are tied closely to those in C:
By default Python have these data types:
 strings - used to represent text data, the text is given under quote marks.
e.g. "ABCD"
 integer - used to represent integer numbers. e.g. -1, -2, -3
 float - used to represent real numbers. e.g. 1.2, 42.42

 boolean - used to represent True or False.

 complex - used to represent complex numbers. e.g. 1.0 + 2.0j, 1.5 + 2.5j
NumPy has some extra data types, and refer to data types with one character,
like i for integers, u for unsigned integers etc.
Below is a list of all data types in NumPy and the characters used to represent
them.
 i - integer
 b - boolean
 u - unsigned integer
 f - float
 c - complex float
 m - timedelta
 M - datetime
 O - object
 S - string
 U - unicode string
 V - fixed chunk of memory for other type ( void )
Type Type code Description
Signed and unsigned 8-bit (1 byte)

int8, uint8 i1, u1
integer types
Signed and unsigned 16-bit integer

int16, uint16 i2, u2
types

types

types

Type Type code Description
float16 f2 Half-precision floating point
Standard single-precision floating

float32 f4 or f
point; compatible with C float
Standard double-precision floating

float64 f8 or d point; compatible with C double and
Python float object
float128 f16 or g Extended-precision floating point
complex64, complex128, c Complex numbers represented by

c8, c16, c32
omplex256 two 32, 64, or 128 floats, respectively
Boolean type
bool ?
storing True and False values
Python object type; a value can be

object O
any Python object
Fixed-length ASCII string type (1 byte

per character); for example, to
string_ S
create a string dtype with length 10,
use 'S10'
Fixed-length Unicode type (number

of bytes platform specific); same
unicode_ U
specification semantics
as string_ (e.g., 'U10')
Table 4-2. NumPy data types

Checking the Data Type of an Array:

The NumPy array object has a property called dtype that returns the data
type of the array:
Example 1:
import numpy as np
arr = np.array([1, 2, 3, 4])
print(arr.dtype)
O/P:
int64
Example 2:
import numpy as np
arr = np.array(['apple', 'banana', 'cherry'])
print(arr.dtype)
O/P:
U6
Creating Arrays With a Defined Data Type:
We use the array() function to create arrays, this function can take an
optional argument: dtype that allows us to define the expected data type of the
array elements:
Example:
import numpy as np
arr = np.array([1, 2, 3, 4], dtype='S')
print("array is",arr)
print("array type is",arr.dtype)
O/P:
array is [b'1' b'2' b'3' b'4']

array type is |S1
We can explicitly convert or cast an array from one dtype to another
using ndarray’s astype method:
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print( arr.dtype)
#Output: dtype('int64')
float_arr = arr.astype(np.float64)
print( float_arr.dtype)
#Output: dtype('float64')
In this example, integers were cast to floating point. If we cast some

floating-point numbers to be of integer dtype, the decimal part will be truncated:
import numpy as np
arr = np.array([3.7, -1.2, -2.6, 0.5, 12.9, 10.1])
print(arr)
#Output: array([ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1])
print(arr.astype(np.int32))
#Output: array([ 3, -1, -2, 0, 12, 10], dtype=int32)
If we have an array of strings representing numbers, we can use astype to

convert them to numeric form:
import numpy as np

numeric_strings = np.array(['1.25', '-9.6', '42'], dtype=np.string_)

print(numeric_strings.astype(float))
#Output: array([ 1.25, -9.6 , 42. ])
Arithmetic with NumPy Arrays:

NumPy is an open-source Python library. It provides a wide range of
arithmetic operations like addition, subtraction, multiplication, and division which
can be performed on the NumPy arrays.
NumPy arithmetic operations are only possible if the arrays should be of
the same shape or if they satisfy the rules of broadcasting.
Addition
import numpy as np
# Defining both the matrices
a = np.array([5, 72, 13, 100])
b = np.array([2, 5, 10, 30])
# Performing addition using arithmetic operator
add_ans = a+b
print(add_ans)
output:
[ 7 77 23 130]
Subtraction
import numpy as np

a = np.array([5, 72, 13, 100])
b = np.array([2, 5, 10, 30])
# Performing subtraction using arithmetic operator

sub_ans = a-b
print(sub_ans)
output:
[ 3 67 3 70]
Multiplication
import numpy as np

a = np.array([5, 72, 13, 100])
b = np.array([2, 5, 10, 30])
# Performing multiplication using arithmetic operator
mul_ans = a*b
print(mul_ans)
output:
[ 10 360 130 3000]
Division
import numpy as np

a = np.array([5, 72, 13, 100])
b = np.array([2, 5, 10, 30])
# Performing division using arithmetic operators

div_ans = a/b
print(div_ans)
[ 2.5 14.4 1.3 3.33333333]

import numpy as np
a = np.array([5, 72, 13, 100])
b = np.array([2, 5, 10, 30])
# Performing addition using arithmetic operator
print(a>b)
print(a/2)
print(a**2)
output:
[ True True True True]
[ 2.5 36. 6.5 50. ]
[ 25 5184 169 10000]
Basic Indexing and Slicing:

indexing and slicing are only applicable to sequence data types. In
sequence type, the order in which elements are inserted is maintained and this
allows us to access its elements using indexing and slicing.
The sequence types in Python are list, tuple, string, range, byte, and byte
arrays. And indexing and slicing apply to all these types.
Numpy indexing is used for accessing an element from an array by giving it
an index value that starts from 0.
Slicing NumPy arrays means extracting elements from an array in a specific
range. It obtains a substring, subtuple, or sublist from a string, tuple, or list.

There are two types of Indexing: basic and advanced. Advanced indexing is
further divided into Boolean and Purely Integer indexing. Negative Slicing index
values start from the end of the array.
To get some specific data or elements from numpy arrays, NumPy indexing
and slicing are used. Indexing starts from 0 and slicing is performed using
indexing.
Indexing an Array
Indexing is used to access individual elements. It is also possible to extract
entire rows, columns, or planes from multi-dimensional arrays with numpy
indexing. Indexing starts from 0. Let's see an array example below to understand
the concept of indexing:
Element
2 3 11 9 6 4 10 12
of array
Index 0 1 2 3 4 5 6 7
Indexing in one dimensions:

When arrays are used as indexes to access groups of elements, this is called
indexing using index arrays. NumPy arrays can be indexed with arrays or with any
other sequence like a list, etc.
Example:
import numpy as np
arr = np.arange(10)
print(arr)
#Output: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
Print( arr[5])
#Output: 5
Print( arr[5:8])
#Output: array([5, 6, 7])
arr[5:8] = 12
print(arr)
#Output: array([ 0, 1, 2, 3, 4, 12, 12, 12, 8, 9])
As you can see, if you assign a scalar value to a slice, as in arr[5:8] = 12, the
value is propagated (or broadcasted henceforth) to the entire selection. An
important first distinction
from Python’s built-in lists is that array slices are views on the original
array. This means that the data is not copied, and any modifications to the view
will be reflected in the source array.
To give an example of this, I first create a slice of arr:
arr_slice = arr[5:8]
print( arr_slice)
Output: array([12, 12, 12])
Now, when I change values in arr_slice, the mutations are reflected in the
original array arr:
arr_slice[1] = 12345
print(arr)
Output:
array([ 0, 1, 2, 3, 4, 12, 12345, 12, 8, 9])
The “bare” slice [:] will assign to all values in an array:

arr_slice[:] = 64
print(arr)
Output:
array([ 0, 1, 2, 3, 4, 64, 64, 64, 8, 9])
Indexing in 2 Dimensions
Example:
import numpy as np
arr=np.arange(12)
arr1=arr.reshape(3,4)
print("Array arr1:\n",arr1)
print("Element at 0th row and 0th column of arr1 is:",arr1[0,0])
print("Element at 1st row and 2nd column of arr1 is:",arr1[1,2])
O/P;
Picking a Row or Column in 2-D NumPy Array

import numpy as np
arr=np.arange(12)
print("\n")
print("1st row :\n",arr1[1])

O/P:
Consider the two-dimensional array from before, arr2d. Slicing this array is
a bit different:
import numpy as np
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr2d[:2])
Output:
array([[1, 2, 3],
[4, 5, 6]])
As you can see, it has sliced along axis 0, the first axis. A slice, therefore,
selects a range of elements along an axis. It can be helpful to read the
expression arr2d[:2] as “select the first two rows of arr2d.”
import numpy as np
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
arr2d[:2, 1:]
Output:

array([[2, 3],
[5, 6]])
When slicing like this, you always obtain array views of the same number of
dimensions. By mixing integer indexes and slices, you get lower dimensional
slices.
For example, I can select the second row but only the first two columns like
so:
import numpy as np
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
arr2d[1, :2]
Out[93]: array([4, 5])
Note that a colon by itself means to take the entire axis, so you can slice
only higher dimensional axes by doing:
import numpy as np
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print( arr2d[:, :1])
Output:
array([[1],
[4],
[7]])
Of course, assigning to a slice expression assigns to the whole selection:

import numpy as np
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
arr2d[:2, 1:] = 0
print( arr2d)
Output:
array([[1, 0, 0],
[4, 0, 0],
[7, 8, 9]])
Indexing in 3 Dimensions
There are three dimensions in a 3-D array, suppose we have three
dimensions as (i, j, k), where i stands for the 1st dimension, j stands for the 2nd
dimension and, k stands for the 3rd dimension.
Example:
import numpy as np
arr=np.arange(12)
arr1=arr.reshape(2,2,3)
print("Element:",arr1[1,0,2])
O/P:

Explanation: We want to access the element of an array at index(1,0,2)

Here 1 represents the 1st dimension, and the 1st dimension has two arrays:
1st array: [0,1,2] [3,4,5] and: 2nd array: [6,7,8] [9,10,11]
Indexing starts from 0.
We have the 2nd array as we select 1: [[6,7,8] [9,10,11]
The 2nd digit 0, stands for the 2nd dimension, and the 2nd dimension also
contains two arrays: Array 1: [6, 7, 8] and: Array 2: [9, 10, 11]
0 is selected and we have 1st array : [6, 7, 8]
The 3rd digit 2, represents the 3rd dimension, 3rd dimension further has
three values: 6,7,8
As 2 is selected, 8 is the output.
Basic Slicing and indexing

Using basic indexing and slicing we can access a particular element or group
of elements from an array.
Basic indexing and slicing return the views of the original arrays.
Basic slicing occurs when the arr[index] is:
 a slice object (constructed by start: stop: step)
 an integer
 or a tuple of slice objects and integers
Example:
import numpy as np
arr = np.arange(12)
print(arr)
print("Element at index 6 of an array arr:",arr[6])
print("Element from index 3 to 8 of an array arr:",arr[3:8])
O/P:

Slicing a 2D Array
In a 2-D array, we have to specify start:stop 2 times. One for the row and 2nd one
for the column.
Exampl:
import numpy as np
arr=np.arange(12)
print("\n")
print("elements of 1st row and 1st column upto last column :\n",arr1[1:,1:4])
O/P:
The 1st number represents the row, so slicing starts from the 1st row and
goes till the last as no ending index is mentioned. Then elements from the 1st
column to the 3rd column are sliced and printed as output.

Negative Slicing and Indexing

Negative indexing begins when the array sequence ends, i.e. the last
element will be the first element with an index of -1 in negative indexing, and the
slicing occurs by using this negative indexing.
Example:
import numpy as np
arr = np.array([10,20,30,40,50,60,70,80,90])
print("Element at index 2 or -7 of an array arr:",arr[-7])
print("Sliced Element from index -8 or 2 and -3 or 6 of an array arr:",arr[-8:-3])
O/P:

Boolean Indexing:
Boolean indexing occurs when the obj is a Boolean array object, i.e., a true or
false type or having some condition.
 The elements that satisfy the Boolean expression are returned.
 This is used to filter the values of the desired elements.
Example:
import numpy as np
arr = np.array([11,6,41,10,29,50,55,45])
print(arr[arr>35])
O/P:
Elements that satisfy the given condition, i.e., greater than 35, are printed
as output
Import numpy as np
names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
data = np.random.randn(7, 4)
print( names)
print( data)
names == 'Bob'
data[names == 'Bob']
data[names == 'Bob', 2:]
data[names == 'Bob', 3]

Output:
array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'], dtype='<U4')
array([[ 0.0929, 0.2817, 0.769 , 1.2464],
[ 1.0072, -1.2962, 0.275 , 0.2289],
[ 1.3529, 0.8864, -2.0016, -0.3718],
[ 1.669 , -0.4386, -0.5397, 0.477 ],
[ 3.2489, -1.0212, -0.5771, 0.1241],
[ 0.3026, 0.5238, 0.0009, 1.3438],
[-0.7135, -0.8312, -2.3702, -1.8608]])
array([ True, False, False, True, False, False, False])
array([[ 0.0929, 0.2817, 0.769 , 1.2464],
[ 1.669 , -0.4386, -0.5397, 0.477 ]])
array([[ 0.769 , 1.2464],
[-0.5397, 0.477 ]])
array([1.2464, 0.477 ])
Transposing Arrays and Swapping Axes:

The numpy.transpose() function is one of the most important functions in
matrix multiplication. This function permutes or reserves the dimension of the
given array and returns the modified array.
The numpy.transpose() function changes the row elements into column
elements and the column elements into row elements. The output of this function
is a modified array of the original one.
Syntax
numpy.transpose(arr, axis=None)
Transposing is a special form of reshaping that similarly returns a view on
the under‐ lying data without copying anything. Arrays have the transpose
method and also the special T attribute:

Example:
import numpy as np
a= np.arange(6).reshape((2,3))
print("array",a)
b=np.transpose(a)
print("transpose array",b )
O/P:
numpy.transpose() with axis

For higher dimensional arrays, transpose will accept a tuple of axis numbers to
permute the axes (for extra mind bending):
import numpy as np
a= np.arange(16).reshape(2, 2, 4)
print("array is\n",a)
print("\n")
b=a.transpose(0, 1,2)
print("transpose with axes\n",b)
O/P:

Simple transposing with .T is just a special case of swapping axes. ndarray

has the method swapaxes which takes a pair of axis numbers:
import numpy as np
a= np.arange(16).reshape(2, 2, 4)
print("array is\n",a)
print("\n")
b=a.swapaxes(1,2)
print("transpose with swapaxes\n",b)
O/P:
Universal Functions: Fast Element-Wise Array

These are two types of universal functions
1.unary ufuncs.
2.binary ufunc(such as add or maximum, take 2 arrays (thus, binary ufuncs) and
return a single array as the result)
A universal function, or ufunc, is a function that performs element-wise
operations on data in ndarrays. You can think of them as fast vectorized wrappers
for simple functions that take one or more scalar values and produce one or more
scalar results.

unary ufuncs.
Compute the absolute value element-wise for integer,

abs, fabs
floating-point, or complex values
Compute the square root of each element (equivalent

sqrt
to arr ** 0.5)
Compute the square of each element (equivalent to arr

square
** 2)
exp Compute the exponent ex of each element
Natural logarithm (base e), log base 10, log base 2, and
log, log10, log2, log1p
log(1 + x), respectively
Compute the sign of each element: 1 (positive), 0

sign
(zero), or –1 (negative)
Compute the ceiling of each element (i.e., the smallest

ceil
integer greater than or equal to that number)
Compute the floor of each element (i.e., the largest

floor
integer less than or equal to each element)
Round elements to the nearest integer, preserving

rint
the dtype
Return fractional and integral parts of array as a

modf
separate array
isnan Return boolean array indicating whether each value

is NaN (Not a Number)
Return boolean array indicating whether each element

isfinite, isinf
is finite (non-inf, non-NaN) or infinite, respectively
cos, cosh, sin, sinh, tan,

Regular and hyperbolic trigonometric functions
tanh
arccos, arccosh, arcsin,

Inverse trigonometric functions
arcsinh, arctan, arctanh
Compute truth value of not x element-wise (equivalent

logical_not
to ~arr).
import numpy as np
arr = np.arange(10)
print("array is\n",arr)
print("\n")
a=np.sqrt(arr)
print("square root\n",a)
print("\n")
b=np.exp(arr)
print("exponent is\n",b)
O/p:

Binary ufunc:
add Add corresponding elements in arrays
subtract Subtract elements in second array from first array
multiply Multiply array elements
divide, floor_divide Divide or floor divide (truncating the remainder)
Raise elements in first array to powers indicated

power
in second array
maximum, fmax Element-wise maximum; fmax ignores NaN
minimum, fmin Element-wise minimum; fmin ignores NaN
mod Element-wise modulus (remainder of division)
Copy sign of values in second argument to values

copysign
in first argument
Perform element-wise comparison, yielding

greater, greater_equal, less,
boolean array (equivalent to infix operators >, >=,
less_equal, equal, not_equal
<, <=, ==, !=)

logical_and, logical_or, Compute element-wise truth value of logical

logical_xor operation (equivalent to infix operators & |, ^)
import numpy as np
arr = np.arange(5)
arr1=np.arange(5,10)
print("arr",arr)
print("\n")
print("arr1",arr1)
print("add is\n",np.add(arr,arr1))
print("div is\n",np.divide(arr,arr1))
O/P:
Mathematical and Statistical Methods:

Math Methods
NumPy contains a large number of various mathematical operations.
NumPy provides standard trigonometric functions, functions for arithmetic
operations, handling complex numbers, etc.

Trigonometric Functions
NumPy has standard trigonometric functions which return trigonometric
ratios for a given angle in radians.
FUNCTION DESCRIPTION
sin() Compute sin element wise
cos() Compute cos element wise
tan() Compute tangent element-wise.
degrees() Convert angles from radians to degrees.
rad2deg() Convert angles from radians to degrees.
deg2rad Convert angles from degrees to radians.
radians() Convert angles from degrees to radians.
numpy.sin(x) : This mathematical function helps user to calculate trignmetric sine

for all x(being the array elements).
numpy.cos(x) : This mathematical function helps user to calculate trignmetric
cosine for all x(being the array elements).
numpy.tan(x) : This mathematical function helps user to calculate trignmetric tan

for all x(being the array elements).
Example
import numpy as np
a = np.array([0,30,45,60,90])
print ('Sine of different angles:' )

# Convert to radians by multiplying with pi/180
print (np.sin(a*np.pi/180) )
print ('\n' )
print ('Cosine values for angles in array:' )

print (np.cos(a*np.pi/180) )
print ('\n' )
print ('Tangent values for given angles:' )

print (np.tan(a*np.pi/180))
Here is its output −

Sine of different angles:
[ 0. 0.5 0.70710678 0.8660254 1. ]
Cosine values for angles in array:

[ 1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
6.12323400e-17]
FUNCTION DESCRIPTION
rint() Round to nearest integer towards zero.
fix() Round to nearest integer towards zero.

floor() Return the floor of the input, element-wise.
ceil() Return the ceiling of the input, element-wise.
Return the truncated value of the input, element-

trunc() wise.
numpy.round_(arr, decimals = 0, out = None) : This mathematical function round

an array to the given number of decimals.
# Python program explaining

# round_() function
import numpy as np
in_array = [.5, 1.5, 2.5, 3.5, 4.5, 10.1]

print ("Input array : \n", in_array)
round_off_values = np.round_(in_array)
print ("\nRounded values : \n", round_off_values)
in_array = [.53, 1.54, .71]

print ("\nInput array : \n", in_array)
round_off_values = np.round_(in_array)
in_array = [.5538, 1.33354, .71445]

print ("\nInput array : \n", in_array)
round_off_values = np.round_(in_array, decimals = 3)

Output :
Input array :
[0.5, 1.5, 2.5, 3.5, 4.5, 10.1]
Rounded values :
[ 0. 2. 2. 4. 4. 10.]
Input array :
[0.53, 1.54, 0.71]
Rounded values :
[ 1. 2. 1.]
Input array :
[0.5538, 1.33354, 0.71445]
Rounded values :
[ 0.554 1.334 0.714]
Statistics Methods
Numpy provides various statistical functions which are used to perform some
statistical data analysis.
 Mean
 Median
 Range (peak to peak)
 Standard Deviation

 Variance
np.mean
Compute the arithmetic mean of an array along a specific axis. The default is
along the flattened axis. For example-
import numpy as np
array_for_mean = np.array([[1, 2], [3, 4]])

m=np.mean(array_for_mean) #default
print(array_for_mean)
print("mean",m)
y=np.mean(array_for_mean, axis = 1) #mean to be calculated along axis

print("mean axis",y)
output:
[[1 2]
[3 4]]
mean 2.5
mean axis [1.5 3.5]
np.median
computes the median of the array along a specific axis. Median is the middle
value in a sorted (ascending/descending) list of numbers.
import numpy as np
array_for_median = np.array([[10, 7, 4], [3, 2, 1]])
x=np.median(array_for_median) #default
print(array_for_median)
print("Median", x)
output:

[[10 7 4]
[ 3 2 1]]
Median 3.5
Ordering the elements of the array in ascending order we get- 1, 2, 3, 4, 7,

10. It is an even-numbered list of 6 elements. The middlemost should be the 3rd
element. The average of the 3rd and 4th elements is taken (since the order is
even-numbered)- (3+4)/2 = 7/2 = 3.5
np.ptp
measures the range along a specific axis of an array. The range is the
difference between the maximum and minimum values in a matrix/array.
import numpy as np
array_for_range = np.array([[-85, 60, 94, 53],
[3, -12, 54, 14],
[32, 45, -66, 36]])
x=np.ptp(array_for_range)
print(x)
The maximum value is 94 while the minimum value is -85. The range will be:
(94- (-85)) = (94+85) = 179
np.std
The standard deviation is the spread of the values from their mean
value. np.stdis the NumPy function which helps to measure the standard deviation
of an array along a specified axis.
import numpy as np
array_for_stddev = np.array([[7, 8, 9], [10, 11, 12]])
x=np.std(array_for_stddev)

print(array_for_stddev)
print("standard deviation",x)
output:
[[ 7 8 9]
[10 11 12]]
standard deviation 1.707825127659933
np.var
np.var is the NumPy function which measures the variance of an array along
a specified axis. Variance is the average squared deviations from the mean of all
observed values.
import numpy as np
array_for_variance = np.array([[1, 2, 3], [6, 7, 8]])
x=np.var(array_for_variance) #default
print(array_for_variance)
print("variance",x)
output:
[[1 2 3]
[6 7 8]]
variance 6.916666666666667
Method Description
Sum of all the elements in the array or along an axis; zero-

sum
length arrays have sum 0

Method Description
mean Arithmetic mean; zero-length arrays have NaN mean
Standard deviation and variance, respectively, with optional

std, var
degrees of freedom adjustment (default denominator n)
min, max Minimum and maximum
argmin,
Indices of minimum and maximum elements, respectively
argmax
cumsum Cumulative sum of elements starting from 0
cumprod Cumulative product of elements starting from 1
Table 4-5. Basic array statistical methods
Sorting:
Like Python’s built-in list type, NumPy arrays can be sorted in-place using the sort
method:
Syntax
list.sort(reverse=True|False, key=myFunc)
Parameter Description
reverse Optional. reverse=True will sort the list descending. Default is

reverse=False
key Optional. A function to specify the sorting criteria(s)
Example:
import numpy as np

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

print(np.sort(arr))
print("\n")
arr1 = np.array(['banana', 'cherry', 'apple'])
print(np.sort(arr1))
print("\n")
arr2 = np.array([[3, 2, 4], [5, 0, 1]])
print(np.sort(arr2))
O/P:
Unique and Other Set Logic

NumPy has some basic set operations for one-dimensional ndarrays. Probably the
most commonly used one is np.unique, which returns the sorted unique values in
an array
Example:
import numpy as np
names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
print( np.unique(names))
ints = np.array([3, 3, 3, 2, 2, 1, 1, 4, 4])
print( np.unique(ints))
O/P:

Another function, np.in1d, tests membership of the values in one array in

another, returning a boolean array
Example:
import numpy as np
values = np.array([6, 0, 0, 3, 2, 5, 6])
print( np.in1d(values, [2, 3, 6]))
O/P:
Array set operations

Unit III Python

Uploaded by

Copyright:

Available Formats

Unit III Python

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Unit III Python

Uploaded by

Copyright:

Available Formats

Unit – III Python for Data Science

B V Raju College Page 1

Now let’s multiply each sequence by 2:

%time for _ in range(10): my_list2 = [x * 2 for x in my_list]

Difference Between List and Array:

Lists do not support element wise Arrays support element wise

List is a part of core Python. Array (ndarray) is a part of NumPy

B V Raju College Page 2

THE NUMPY NDARRAY: A MULTIDIMENSIONAL ARRAY OBJECT

One of the key features of NumPy is its N-dimensional array object, or

data= data + data

[[ 10.27690378 -4.54007811 -10.91347855]

[[ 20.55380756 -9.08015622 -21.82695709]

B V Raju College Page 3

B V Raju College Page 4

b = np.array([1.2, 3.5, 5.1])

Array transforms sequences of sequences into two-dimensional arrays,

print("two dim array",b)

To create sequences of numbers, NumPy provides a function analogous to

np.arange( 0, 2, 0.3 ) # it accepts float arguments

B V Raju College Page 6

Convert input data (list, tuple, array, or other sequence type) to an

Convert input to ndarray, but do not copy if the input is already an

B V Raju College Page 7

Produce an array of all 1s with the given shape and

eye, Create a square N × N identity matrix (1s on the diagonal and 0s

Table 4-1. Array creation functions

Data Types for ndarrays:

B V Raju College Page 8

 boolean - used to represent True or False.

Type Type code Description

Signed and unsigned 8-bit (1 byte)

Signed and unsigned 16-bit integer

Signed and unsigned 32-bit integer

Signed and unsigned 64-bit integer

B V Raju College Page 9

Type Type code Description

float16 f2 Half-precision floating point

Standard single-precision floating

Standard double-precision floating

float128 f16 or g Extended-precision floating point

complex64, complex128, c Complex numbers represented by

Python object type; a value can be

Fixed-length ASCII string type (1 byte

Fixed-length Unicode type (number

Table 4-2. NumPy data types

B V Raju College Page 10

Checking the Data Type of an Array:

array is [b'1' b'2' b'3' b'4']

In this example, integers were cast to floating point. If we cast some

If we have an array of strings representing numbers, we can use astype to

B V Raju College Page 12

numeric_strings = np.array(['1.25', '-9.6', '42'], dtype=np.string_)

#Output: array([ 1.25, -9.6 , 42. ])

Arithmetic with NumPy Arrays:

# Defining both the matrices

# Performing subtraction using arithmetic operator

# Defining both the matrices

# Defining both the matrices

B V Raju College Page 14