Skip to main content

python numpy tutorial

NUMPY.APPEND () IN PYTHON:

v  This function adds values at the end of an input array as the name suggests, append means adding something.

v  The numpy.append() function is used to add or append new values to an existing numpy array. 

v  This function adds the new values at the end of the array.

 

SYNTAX:

numpy.append( arr, values, axis=None)  

                                                                                   

SAMPLE INPUT:

import numpy as np  

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

b=np.array([[10, 20, 30], [40, 50, 60], [70, 80, 90]])  

c=np.append(a,b)  

c  

 

OUTPUT:

array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 20, 30, 40, 50, 60, 70, 80,90])


NumPy Broadcasting

v  The term broadcasting refers to the ability of NumPy to treat arrays of different shapes during arithmetic operations

v   NumPy can perform such operations where the array of different shapes are involved.

Example

v  If we consider the matrix multiplication operation, if the shape of the two matrices is the same then this operation will be easily performed.

v  However, we may also need to operate if the shape is not similar.

Sample Input:

import numpy as np  

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

b = np.array([2,4,6,8,10,12,14])  

c = a*b;  

print(c)

Output:

[ 2 8 18 32 50 72 98]

 

NUMPY.ARRANGE() IN PYTHON:

v  It creates an array by using the evenly spaced values over the given interval. 

v  The interval mentioned is half opened i.e. [Start, Stop]).

v  NumPy arange() is one of the array creation routines based on numerical ranges

v   It creates an instance of ndarray with evenly spaced values and returns the reference to it.

 

SYNTAX:

 

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

 

PARAMETERS:

 

It accepts the following parameters.

  1. start: The starting of an interval. The default is 0.
  2. stop: represents the value at which the interval ends excluding this value.
  3. step: The number by which the interval values change.
  4. dtype: the data type of the numpy array items.

SAMPLE INPUT:

1.    import numpy as np  

2.    arr = np.arange(0,12,2,float)  

3.    print(arr)

 

OUTPUT:

[ 0. 2. 4. 6. 8.10]

 

 

 NUMPY.AVERAGE() IN PYTHON:

v  The numpy module of Python provides a function called numpy.

v  Average (), used for calculating the weighted average along the specified axis.

SYNTAX:

Numpy.average(a, axis=None, weights=None, returned=False)  

 

                                                                                   

SAMPLE INPUT:

 

import numpy as np  

data = list (range (1,7))  

output=np. average(data)  

data  

output  

 

OUTPUT:

 

[1, 2, 3, 4, 5, 6]

 

3.5

 

 Numpy ceil()

v  This function returns the ceil value of the input array elements.

v  The floor of a number x is i if i is the smallest integer such that, i>=x.

 

Syntax:

numpy.ceil(array)  

Parameters:

array: Array elements whose ceil values are to be calculated.

                                                                                   

Sample Input:

import numpy as np  

arr = [0.23, 0.09, 1.2, 1.24, 9.90]  

print("Input array:",arr)  

r_arr = np.ceil(arr)  

print("Output array:",r_arr)  

arr2 = [145.23, 0.12, 12.34, 123]  

 r_arr2=np.ceil(arr2)  

 print("Input array:",arr2)  

 print("Output array:",r_arr2)  

 

Output:

Input array: [0.23, 0.09, 1.2, 1.24, 9.90]

Output array: [ 1.  1.  2.  2. 10.]

Input array: [145.26, 1.12, 13.34, 123]

Output array: [146.   2.  14. 123.]

 

NUMPY.CLIP() IN PYTHON

v  function is used to Clip (limit) the values in an array.

v  In the clip() function, we will pass the interval, and the values which are outside the interval will be clipped for the interval edges.

SYNTAX:

numpy.clip(a, a_min, a_max, out=None)  

                                                                                               

SAMPLE INPUT:

import numpy as np  

x= np.arange(12)  

y=np.clip(x, 3, 11)  

y  

 

SAMPLE OUTPUT:

 

Array ([ 3, 3, 3, 3, 4, 5, 6, 7, 8, 9,10,11,11])

 

NUMPY CONCATENATE() IN PYTHON

v  The concatenate () function is a function from the NumPy package. This function essentially combines NumPy arrays together.

v  This function is basically used for joining two or more arrays of the same shape along a specified axis.

There are the following things which are essential to keep in mind:

v  NumPy's concatenate () is not like a traditional database join. It is like stacking NumPy arrays.

v  This function can operate both vertically and horizontally. This means we can concatenate arrays together horizontally or vertically.

The concatenate () function is usually written as np.concatenate(), but we can also write it as numpy.concatenate().

 

SYNTAX:

numpy.concatenate((a1, a2, ...), axis)  

 

SAMPLE INPUT:

import numpy as np  

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

y=np.array([[12,30]])  

z=np.concatenate((x,y))  

z  

 

OUTPUT:

array([[ 1,  3],[ 2,  4],[12, 30]])


NUMPY.dot() in python:

v  The function is used to perform a product of two dot arrays.

v  If both the arrays 'a' and 'b' are 1-dimensional arrays, the dot() function performs the inner product of vectors (without complex conjugation).

v  If both the arrays 'a' and 'b' are 2-dimensional arrays, the dot() function performs the matrix multiplication. But for matrix multiplication use of matmul or 'a' @ 'b' is preferred.

v  If either 'a' or 'b' is 0-dimensional (scalar), the dot() function performs multiplication. Also, the use of numpy.multiply(a, b) or a *b method is preferred.

SYNTAX:

Numpy.dot(a,b,out=None)

                                                                                         

SAMPLE INPUT

import numpy as np  

a=np.dot(8,12)  

a  

 

OUTPUT:

96

 

 NUMPY FLOOR() IN  PYTHON:

v  This function returns the floor value of the input array elements. 

v  The floor of a number x is i if i is the largest integer such that, i<=x.

SYNTAX:

numpy.floor(array)

                                                                                   

SAMPLE INPUT:

import numpy as np

in_array = [.5, 1.5, 2.5, 3.5, 4.5, 10.1]

print ("Input array : \n", in_array)

floor off values = np.floor( in array)

print ("\n Rounded values : \n", floor off values)

in_array = [.53, 1.54, .71]

print ("\nInput array : \n", in_array)

flooroff_values = np.floor(in_array)

print ("\n Rounded values : \n", flooroff_values)

in_array = [.5538, 1.33354, .71445]

print ("\n Input array : \n", in_array)

flooroff_values = np.floor(in_array)

print ("\n Rounded values : \n", flooroff_values)

 

OUTPUT:

 

Input array:

 

[0.5, 1.5, 2.5, 3.5, 4.5, 10.1]

 

Rounded values:

 

[ 0.   1.   2.   3.   4.  10.]

 

Input array:

 

[0.53, 1.54, 0.71]

 

Rounded Values:

 

[ 0.  1.  0.]

Input array:

 

[0.5538, 1.33354, 0.71445]

 

Rounded Values:

 

[ 0.  1.  0.]

 

NUMPY.FROMBUFFER()

v  This function is used to create an array by using the specified buffer.

SYNTAX:

numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)

 

PARAMETERS  

It accepts the following parameters.

v  buffer: It represents an object that exposes a buffer interface.

v  dtype: It represents the data type of the returned data type array. The default value is 0.

v  count: It represents the length of the returned ndarray.

v  offset: It represents the starting position to read from. The default value is 0.

SAMPLE INPUT:

import numpy as np  

l = c'hello world'  

print(type(l))  

a = np.frombuffer(l, dtype = "S1")  

print(a)  

print(type(a))

 

OUTPUT:

 

[c'h' c'e' c'l' c'l' c'o' c' ' c'w' c'o' c'r' c'l' c'd']

 

 NUMPY HYPOT() METHOD:

v  This function is used to calculate the hypotenuse for the right angled triangle

v  The hypotenuse of the right angle is calculated as:

SYNTAX

numpy.hypot(array1, array2 out) 

PARAMETERS:

  1. array1: It is the input array of bases of the given right angled triangles.
  2. array2: It is the input array of perpendiculars of the given right angled triangles.
  3. Out: It is the shape of the output array.

SAMPLE INPUT:

import numpy as np  

base = [10,2,5,50]  

per= [3,10,23,6]  

print("Input base array:",base)  

print("Input perpendicular array:",per)  

hyp = np.hypot(base,per)  

print("hypotenuse ",hyp)  

 

OUTPUT:

Input base array: [10, 2, 5, 50]

Input perpendicular array: [3, 10, 23, 6]

hypotenuse[10.44030651 10.19803903 23.53720459 50.35871325]

 

 NUMPY.LINSPACE()

v  It is similar to the arrange function.

v  It only returns evenly separated values over a specified period.

v  The system implicitly calculates the step size.

SYNTAX:

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

PARAMETERS:

It accepts the following parameters

v  start: It represents the starting value of the interval.

v  stop:It represents the stopping value of the interval.

v  num: The amount of evenly spaced samples over the interval to be generated. The default is 50.

v  endpoint: Its true value indicates that the stopping value is included in the interval.

v  rettstep: This has to be a boolean value. Represents the steps and samples between the consecutive numbers.

v  dtype: It represents the data type of the array items.

SAMPLE INPUT:

import numpy as np  

arr = np.linspace(10, 20, 5)  

print("The array over the given range is ",arr)  

 

OUTPUT:

The array over the given range is [10.  12.5 15.  17.5 20.]

 

 NUMPY.MATLIB.ONES()

v  This function is used to return a new matrix with the values initialized to ones.

SYNTAX:

numpy.matlib.ones(shape,dtype,order)  

PARAMETERS:

It accepts the following parameters.

v  shape: It is the Tuple defining the shape of the matrix.

v  dtype: It is the data type of the matrix.

v  order: It is the insertion order of the matrix.

SAMPLE INPUT:

import numpy as np    

import numpy.matlib    

print(numPy.matlib.ones((3,3)))   

 

OUPUT:

[[1. 1. 1.]

 [1. 1. 1.]

 [1. 1. 1.]]

 

 numpy.mean() in python

v  The sum of elements, along with an axis divided by the number of elements, is known as arithmetic mean.

v  The numpy.mean() function is used to compute the arithmetic mean along the specified axis.

v  This function returns the average of the array elements

v  By default, the average is taken on the flattened array. Else on the specified axis, float 64 is intermediate as well as return values are used for integer inputs

SYNTAX:

numpy.mean(a, axis=None, dtype=None, out=None, keepdims=<no value>)

                                                                                   

SAMPLE CODE:

import numpy as np  

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

b=np.mean(a)  

b  

x = np.array([[5, 6], [7, 34]])  

y=np.mean(x)  

y  

 

OUTPUT:

2.5

13.0

 

 

EXAMPLE 2:

 

import numpy as np  

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

b=np.mean(a,axis=0)  

c=np.mean(a,axis=1)  

b  

c  

 

OUTPUT:

 

array([2.5, 4.5])

array([3., 4.])

 

 

 

 NUMPY.SAVE() IN PYTHON:

 

v  This module used to provide a numpy.save() function.

v  To extention an array into a binary file in .npy format

v  In many of the cases, we require data in binary format to manipulate it.

SYNTAX:

numpy.save(file, arr, allow_pickle=True, fix_imports=True)  

                                                                                               

SAMPLE INPUT:

import numpy as np  

from tempfile import TemporaryFile  

out_file = TemporaryFile()  

x=np.arange(16)  

np.save(out_file, x)  

_=out_file.seek(1) # Only needed here to simulate closing & reopening file  

np.load(outfile) 

 

OUTPUT:

 

array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,15])


NUMPY STATISTICAL FUNCTIONS:

v  Numpy has quite a few useful statistical functions for finding minimum, maximum, percentile standard deviation and variance, etc. from the given elements in the array. 

Function

NumPy

Min

np. min()

Max

np. max()

Mean

np. mean()

Median

np. median()

Standard deviation

np. std()

SAMPLE CODE:

 








SAMPLE INPUT:

 

Import NumPy as np

normal_ array=np. random. normal (5,0.5,10)

print (normal_ array)

 

OUTPUT:

[5.56171852 4.84233558 4.65392767 4.946659   4.85165567 5.61211317 4.46704244 5.22675736 4.49888936 4.68731125]

 

 

 

 

 

 

Example: Statistical function

### Min 
print (np. min(normal_ array))
 
### Max 
print (np. max(normal_ array))

 

### Mean 
print (np. mean(normal_ array))

 

### Median
print (np. median(normal_ array))

 

### Sd
print (np. std(normal_ array))

 

OUTPUT:

4.467042435266913
5.612113171990201
4.934841002270593
4.846995625786663
0.3875019367395316

 

 

 

 

 

 

 


Labels:

Comments

Post a Comment

Popular posts from this blog

How to take a walk

  How to Take a Walk                                                                                                                                     How to take a walk|Building a Better Today Whatever your workday looks like, odds are you could use an occasional break. Learn how to make the most of a midday stroll. Forget your phone.  Leaving your screen behind will give your eyes a much-needed rest. Though scrolling through social media may seem like a reward for a productive morning, it will ultimately diminish your ability to be present on your walk Take in your surroundings.   Minus your tech and...
Post a Comment
Read more

Remote Working: Mitigating Risks, Improving Productivity

  Business as usual for organizations the world over has been marred by these extraordinary times. An unprecedented crisis, the COVID-19 pandemic has divided our timeline into pre and post COVID eras.  Some of the business practices that have been prevalent until now may cease to exist or get an upgrade in the post COVID times. Business Continuity Planning: A Change in Approach Ever since 9/11, business continuity planning (BCP) has been an integral part of businesses across industries, especially in the banking and financial services sector. Split or multi-site processing, hot-warm-cold sites, work transfer, and staff transfer were some of the recovery strategies put in place to handle exigencies on ‘off’ days.  Although tested periodically for operational effectiveness, these strategies could not replicate the surprise – in fact, shock – element of real-world contingencies. After having delivered effective results for more than a decade, some events of significant propo...
Post a Comment
Read more

Using Technology to Dodge the Shell Company Fraud

  During the Panama Papers episode, it was found that some of the Mossack Fonseca shell corporations were used for illegal purposes, including fraud, tax evasion, and dodging international sanctions.  The incident also highlighted the use of shell companies in facilitating high level financial crime. The scale of the episode was a shock as was the detail and meticulous planning it took to set this off using shell companies. A shell company is an inactive establishment used as a vehicle for probable financial crimes or kept dormant for future use in some other capacity.  This company only exists only on paper and has no brick and mortar presence or employees.  Identifying a shell company has been a constant struggle for the financial institutions and the approach has been evolving over the past years. In addition to using a shell firm, there is also widespread use of mirror trades in financial crime.  A combination of shell companies and mirror trades originating...
Post a Comment
Read more