[ad_1]
NumPy, which stands for Numerical Python, is a library consisting of multidimensional array objects and a collection of routines for processing those arrays. Using NumPy, mathematical and logical operations on arrays can be performed.
NumPy is a Python package. It stands for ‘Numerical Python’. It is a library consisting of multidimensional array objects and a collection of routines for processing of array.
Numeric, the ancestor of NumPy, was developed by Jim Hugunin. Another package Numarray was also developed, having some additional functionalities. In 2005, Travis Oliphant created NumPy package by incorporating the features of Numarray into Numeric package. There are many contributors to this open-source project.
Operations using NumPy
Using NumPy, a developer can perform the following operations −
- Mathematical and logical operations on arrays.
- Fourier transforms and routines for shape manipulation.
- Operations related to linear algebra. NumPy has in-built functions for linear algebra and random number generation.
NumPy – A Replacement for MatLab
NumPy is often used along with packages like SciPy (Scientific Python) and Matplotlib (plotting library). This combination is widely used as a replacement for MatLab, a popular platform for technical computing. However, Python alternative to MatLab is now seen as a more modern and complete programming language.
It is open-source, which is an added advantage of NumPy.
The most important object defined in NumPy is an N-dimensional array type called ndarray. It describes the collection of items of the same type. Items in the collection can be accessed using a zero-based index.
Every item in a ndarray takes the same size as the block in the memory. Each element in ndarray is an object of the data-type object (called dtype).
Any item extracted from ndarray object (by slicing) is represented by a Python object of one of array scalar types. The following diagram shows a relationship between ndarray, data-type object (dtype) and array scalar type −
An instance of ndarray class can be constructed by different array creation routines described later in the tutorial. The basic ndarray is created using an array function in NumPy as follows-
numpy.array
It creates a ndarray from any object exposing an array interface, or from any method that returns an array.
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
The ndarray object consists of a contiguous one-dimensional segment of computer memory, combined with an indexing scheme that maps each item to a location in the memory block. The memory block holds the elements in row-major order (C style) or a column-major order (FORTRAN or MatLab style).
The above constructor takes the following parameters −
| Sr.No. | Parameter & Description |
| 1 | object Any object exposing the array interface method returns an array or any (nested) sequence. |
| 2 3 |
dtype The desired data type of array, optionalcopyOptional. By default (true), the object is copied |
| 4 | orderC (row-major) or F (column-major) or A (any) (default) |
| 5 | subok By default, returned array forced to be a base class array. If true, sub-classes passed through |
| 6 | ndmin Specifies minimum dimensions of the resultant array |
Take a look at the following examples to understand better.
Example 1
Live Demo
import numpy as np
a = np.array([1,2,3])
print a
The output is as follows –
[1, 2, 3]
Example 2
Live Demo
# more than one dimensions
import numpy as np
a = np.array([[1, 2], [3, 4]])
print a
The output is as follows −
[[1, 2]
[3, 4]]
Example 3
Live Demo
# minimum dimensions
import numpy as np
a = np.array([1, 2, 3,4,5], ndmin = 2)
print a
The output is as follows −
[[1, 2, 3, 4, 5]]
Example 4
Live Demo
# dtype parameter
import numpy as np
a = np.array([1, 2, 3], dtype = complex)
print a
The output is as follows −
[ 1.+0.j, 2.+0.j, 3.+0.j]
The ndarray object consists of a contiguous one-dimensional segment of computer memory, combined with an indexing scheme that maps each item to a location in the memory block. The memory block holds the elements in row-major order (C style) or a column-major order (FORTRAN or MatLab style).
NumPy – Data Types
bool_
Boolean (True or False) stored as a byte
int_
Default integer type (same as C long; normally either int64 or int32)
intc
Identical to C int (normally int32 or int64)
intp
An integer used for indexing (same as C ssize_t; normally either int32 or int64)
int8
Byte (-128 to 127)
int16
Integer (-32768 to 32767)
float_
Shorthand for float64
float64
Double precision float: sign bit, 11 bits exponent, 52 bits mantissa
float64
Double precision float: sign bit, 11 bits exponent, 52 bits mantissa
complex_
Shorthand for complex128
complex64
Complex number, represented by two 32-bit floats (real and imaginary components)
complex128
Complex number, represented by two 64-bit floats (real and imaginary components)
NumPy numerical types are instances of dtype (data-type) objects, each having unique characteristics. The dtypes are available as np.bool_, np.float32, etc.
Data Type Objects (dtype)
A data type object describes the interpretation of a fixed block of memory corresponding to an array, depending on the following aspects −
- Type of data (integer, float or Python object)
- Size of data
- Byte order (little-endian or big-endian)
- In case of structured type, the names of fields, data type of each field and part of the memory block taken by each field.
- If the data type is a subarray, its shape and data type
The byte order is decided by prefixing ‘<‘ or ‘>’ to the data type. ‘<‘ means that encoding is little-endian (least significant is stored in smallest address). ‘>’ means that encoding is big-endian (a most significant byte is stored in smallest address).
A dtype object is constructed using the following syntax −
numpy.dtype(object, align, copy)
The parameters are −
- Object − To be converted to data type object
- Align − If true, adds padding to the field to make it similar to C-struct
- Copy − Makes a new copy of dtype object. If false, the result is a reference to builtin data type object
Example 1
Live Demo
# using array-scalar type
import numpy as np
dt = np.dtype(np.int32)
print dt
The output is as follows −
int32
Example 2
Live Demo
#int8, int16, int32, int64 can be replaced by equivalent string ‘i1’, ‘i2′,’i4’, etc.
import numpy as np
dt = np.dtype(‘i4’)
print dt
The output is as follows −
int32
Example 3
Live Demo
# using endian notation
import numpy as np
dt = np.dtype(‘>i4’)
print dt
The output is as follows −
>i4
The following examples show the use of a structured data type. Here, the field name and the corresponding scalar data type is to be declared.
Example 4
Live Demo
# first create structured data type
import numpy as np
dt = np.dtype([(‘age’,np.int8)])
print dt
The output is as follows – [(‘age’, ‘i1’)]
Example 5
Live Demo
# now apply it to ndarray object
import numpy as np
dt = np.dtype([(‘age’,np.int8)])
a = np.array([(10,),(20,),(30,)], dtype = dt)
print a
The output is as follows –
[(10,) (20,) (30,)]
Each built-in data type has a character code that uniquely identifies it.
- ‘b’ − boolean
- ‘i’ − (signed) integer
- ‘u’ − unsigned integer
- ‘f’ − floating-point
- ‘c’ − complex-floating point
- ‘m’ − timedelta
- ‘M’ − datetime
- ‘O’ − (Python) objects
- ‘S’, ‘a’ − (byte-)string
- ‘U’ − Unicode
- ‘V’ − raw data (void)
We will also discuss the various array attributes of NumPy.
ndarray.shape
This array attribute returns a tuple consisting of array dimensions. It can also be used to resize the array.
Example 1
Live Demo
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print a.shape
The output is as follows −(2, 3)
Example 2
Live Demo
# this resizes the ndarray
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
a.shape = (3,2)
print a
The output is as follows -[[1, 2][3, 4] [5, 6]]
ndarray.ndim
This array attribute returns the number of array dimensions.
Example 1
Live Demo
# an array of evenly spaced numbers
import numpy as np
a = np.arange(24)
print a
The output is as follows −
[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
Example 2
Live Demo
# 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
# b is having three dimensions
The output is as follows −
[[[ 0, 1, 2]
[ 3, 4, 5]
[ 6, 7, 8]
[ 9, 10, 11]]
[[12, 13, 14]
[15, 16, 17]
[18, 19, 20]
[21, 22, 23]]]
numpy.itemsize
This array attribute returns the length of each element of array in bytes.
Example 1
Live Demo
# dtype of array is int8 (1 byte)
import numpy as np
x = np.array([1,2,3,4,5], dtype = np.int8)
print x.itemsize
The output is as follows −
1
Example 2
Live Demo
# dtype of array is now float32 (4 bytes)
import numpy as np
x = np.array([1,2,3,4,5], dtype = np.float32)
print x.itemsize
The output is as follows −
4
numpy.flags
The ndarray object has the following attributes. Its current values are returned by this function.
| Sr.No. | Attribute & Description |
| 1 | C_CONTIGUOUS (C)The data is in a single, C-style contiguous segment |
| 2 | F_CONTIGUOUS (F)The data is in a single, Fortran-style contiguous segment |
| 3 | OWNDATA (O)The array owns the memory it uses or borrows it from another object |
| 4 | WRITEABLE (W)The data area can be written to. Setting this to False locks the data, making it read-only |
| 5 | ALIGNED (A)The data and all elements are aligned appropriately for the hardware |
| 6 | UPDATEIFCOPY (U)This array is a copy of some other array. When this array is deallocated, the base array will be updated with the contents of this array |
Example
The following example shows the current values of flags.
Live Demo
import numpy as np
x = np.array([1,2,3,4,5])
print x.flags
The output is as follows −
C_CONTIGUOUS : True
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
UPDATEIFCOPY : False
NumPy – Array Creation Routines
A new ndarray object can be constructed by any of the following array creation routines or using a low-level ndarray constructor.
numpy.empty
It creates an uninitialized array of specified shape and dtype. It uses the following constructor −
numpy.empty(shape, dtype = float, order = ‘C’)
The constructor takes the following parameters.
| Sr.No. | Parameter & Description |
| 1 | ShapeShape of an empty array in int or tuple of int |
| 2 | DtypeDesired output data type. Optional |
| 3 | Order‘C’ for C-style row-major array, ‘F’ for FORTRAN style column- |
Example
The following code shows an example of an empty array.
Live Demo
import numpy as np
x = np.empty([3,2], dtype = int)
print x
The output is as follows −[[22649312 1701344351]
[1818321759 1885959276] [16779776 156368896]]
numpy.zeros
Returns a new array of specified size, filled with zeros.
numpy.zeros(shape, dtype = float, order = ‘C’)
The constructor takes the following parameters.
| Sr.No. | Parameter & Description |
| 1 | ShapeShape of an empty array in int or sequence of int |
| 2 | DtypeDesired output data type. Optional |
| 3 | Order‘C’ for C-style row-major array, ‘F’ for FORTRAN style column-major array |
Example 1
Live Demo
# array of five ones. Default dtype is float
import numpy as np
x = np.ones(5)
print x
The output is as follows −
[ 1. 1. 1. 1. 1.]
NumPy – Indexing & Slicing
Contents of ndarray object can be accessed and modified by indexing or slicing, just like Python’s in-built container objects.
As mentioned earlier, items in ndarray object follows zero-based index. Three types of indexing methods are available − field access, basic slicing and advanced indexing.
Basic slicing is an extension of Python’s basic concept of slicing to n dimensions. A Python slice object is constructed by giving start, stop, and step parameters to the built-in slice function. This slice object is passed to the array to extract a part of array.
Example 1
Live Demo
import numpy as np
a = np.arange(10)
s = slice(2,7,2)
print a[s]
Its output is as follows −
[2 4 6]
n the above example, an ndarray object is prepared by arange() function. Then a slice object is defined with start, stop, and step values 2, 7, and 2 respectively. When this slice object is passed to the ndarray, a part of it starting with index 2 up to 7 with a step of 2 is sliced.
The same result can also be obtained by giving the slicing parameters separated by a colon : (start:stop:step) directly to the ndarray object.
Example 2
Live Demo
import numpy as np
a = np.arange(10)
b = a[2:7:2]
print b
Here, we will get the same output −[2 4 6]
If only one parameter is put, a single item corresponding to the index will be returned. If a: is inserted in front of it, all items from that index onwards will be extracted. If two parameters (with: between them) is used, items between the two indexes (not including the stop index) with default step one are sliced.
Example 3
Live Demo
# slice single item
import numpy as np
a = np.arange(10)
b = a[5]
print b
Its output is as follows −
5
Example 4
Live Demo
# slice items starting from index
import NumPy as np
a = np.arange(10)
print a[2:]
Now, the output would be −
[2 3 4 5 6 7 8 9]
Example 5
Live Demo
# slice items between indexes
import numpy as np
a = np.arange(10)
print a[2:5]
Here, the output would be −
[2 3 4]
The above description applies to multi-dimensional ndarray too.
NumPy – Advanced Indexing
It is possible to make a selection from ndarray that is a non-tuple sequence, ndarray object of integer or Boolean data type, or a tuple with at least one item being a sequence object. Advanced indexing always returns a copy of the data. As against this, the slicing only presents a view.
There are two types of advanced indexing − Integer and Boolean.
Integer Indexing
This mechanism helps in selecting any arbitrary item in an array based on its N-dimensional index. Each integer array represents the number of indexes into that dimension. When the index consists of as many integer arrays as the dimensions of the target ndarray, it becomes straightforward.
In the following example, one element of the specified column from each row of ndarray object is selected. Hence, the row index contains all row numbers, and the column index specifies the element to be selected.
Example 1
Live Demo
import numpy as np
x = np.array([[1, 2], [3, 4], [5, 6]])
y = x[[0,1,2], [0,1,0]]
print y
Its output would be as follows −
[1 4 5]
The selection includes elements at (0,0), (1,1) and (2,0) from the first array.
In the following example, elements placed at corners of a 4X3 array are selected. The row indices of selection are [0, 0] and [3,3] whereas the column indices are [0,2] and [0,2].
Advanced and basic indexing can be combined by using one slice (:) or ellipsis (…) with an index array. The following example uses a slice for the advanced index for column. The result is the same when a slice is used for both. But advanced index results in copy and may have different memory layout.
Boolean Array Indexing
This type of advanced indexing is used when the resultant object is meant to be the result of Boolean operations, such as comparison operators.
Example 1
In this example, items greater than 5 are returned as a result of Boolean indexing.
Live Demo
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’
# Now we will print the items greater than 5
print ‘The items greater than 5 are:’
print x[x > 5]
The output of this program would be −
Our array is:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
The items greater than 5 are:
[ 6 7 8 9 10 11]
NumPy – Broadcasting
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. If two arrays are of exactly the same shape, then these operations are smoothly performed.
Example 1
import numpy as np
a = np.array([1,2,3,4])
b = np.array([10,20,30,40])
c = a * b
print c
Its output is as follows −[10 40 90 160]
If the dimensions of the two arrays are dissimilar, element-to-element operations are not possible. However, operations on arrays of non-similar shapes is still possible in NumPy, because of the broadcasting capability. The smaller array is broadcast to the size of the larger array so that they have compatible shapes.
Broadcasting is possible if the following rules are satisfied −
- Array with smaller ndim than the other is prepended with ‘1’ in its shape.
- Size in each dimension of the output shape is maximum of the input sizes in that dimension.
- An input can be used in calculation if its size in a particular dimension matches the output size or its value is exactly 1.
- If an input has a dimension size of 1, the first data entry in that dimension is used for all calculations along that dimension.
A set of arrays is said to be broadcastable if the above rules produce a valid result and one of the following is true −
- Arrays have exactly the same shape.
- Arrays have the same number of dimensions and the length of each dimension is either a common length or 1.
- Array having too few dimensions can have its shape prepended with a dimension of length 1, so that the above stated property is true.
The following figure demonstrates how array b is broadcast to become compatible with a.
NumPy – Iterating Over Array
NumPy package contains an iterator object numpy.nditer. It is an efficient multidimensional iterator object using which it is possible to iterate over an array. Each element of an array is visited using Python’s standard Iterator interface.
Let us create a 3X4 array using arrange() function and iterate over it using nditer.
NumPy – Array Manipulation
Several routines are available in NumPy package for manipulation of elements in ndarray object. They can be classified into the following types −
Changing Shape
| Sr.No. | Shape & Description |
| 1 | reshapeGives a new shape to an array without changing its data |
| 2 | flatA 1-D iterator over the array |
| 3 | flattenReturns a copy of the array collapsed into one dimension |
| 4 | ravelReturns a contiguous flattened array |
Transpose Operations
| Sr.No. | Operation & Description |
| 1 | transposePermutes the dimensions of an array |
| 2 | ndarray.TSame as self.transpose() |
| 3 | rollaxisRolls the specified axis backwards |
| 4 | swapaxesInterchanges the two axes of an array |
Changing Dimensions
| Sr.No. | Dimension & Description |
| 1 | broadcastProduces an object that mimics broadcasting |
| 2 | broadcast_toBroadcasts an array to a new shape |
| 3 | expand_dimsExpands the shape of an array |
| 4 | squeezeRemoves single-dimensional entries from the shape of an array |
Joining Arrays
| Sr.No. | Array & Description |
| 1 | concatenateJoins a sequence of arrays along an existing axis |
| 2 | stackJoins a sequence of arrays along a new axis |
| 3 | hstackStacks arrays in sequence horizontally (column wise) |
| 4 | vstackStacks arrays in sequence vertically (row wise) |
Splitting Arrays
| Sr.No. | Array & Description |
| 1 | splitSplits an array into multiple sub-arrays |
| 2 | hsplitSplits an array into multiple sub-arrays horizontally (column-wise) |
| 3 | vsplitSplits an array into multiple sub-arrays vertically (row-wise) |
Adding / Removing Elements
| Sr.No. | Element & Description |
| 1 | resizeReturns a new array with the specified shape |
| 2 | appendAppends the values to the end of an array |
| 3 | insertInserts the values along the given axis before the given indices |
| 4 | deleteReturns a new array with sub-arrays along an axis deleted |
| 5 | uniqueFinds the unique elements of an array |
NumPy – Binary Operators
Following are the functions for bitwise operations available in NumPy package.
| Sr.No. | Operation & Description |
| 1 | bitwise_andComputes bitwise AND operation of array elements |
| 2 | bitwise_orComputes bitwise OR operation of array elements |
| 3 | invertComputes bitwise NOT |
| 4 | right_shiftShifts bits of binary representation to the right |
NumPy – Mathematical Functions
Quite understandably, 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.
Example
Live Demo
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]
Tangent values for given angles:
[ 0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
1.63312394e+16]
arcsin, arcos, and arctan functions return the trigonometric inverse of sin, cos, and tan of the given angle. The result of these functions can be verified by numpy.degrees() function by converting radians to degrees.
Functions for Rounding
numpy.around()
This is a function that returns the value rounded to the desired precision. The function takes the following parameters.
numpy.around(a,decimals)
Where,
| Sr.No. | Parameter & Description |
| 1 | aInput data |
| 2 | decimalsThe number of decimals to round to. Default is 0. If negative, the integer is rounded to position to the left of the decimal point |
NumPy – Statistical Functions
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. The functions are explained as follows −
numpy.amin() and numpy.amax()numpy.amin() and numpy.amax()
These functions return the minimum and the maximum from the elements in the given array along the specified axis.
Example
Live Demo
import numpy as np
a = np.array([[3,7,5],[8,4,3],[2,4,9]])
print ‘Our array is:’
print a
print ‘n’
print ‘Applying amin() function:’
print np.amin(a,1)
print ‘n’
print ‘Applying amin() function again:’
print np.amin(a,0)
print ‘n’
print ‘Applying amax() function:’
print np.amax(a)
print ‘n’
print ‘Applying amax() function again:’
print np.amax(a, axis = 0)
It will produce the following output −
Our array is:
[[3 7 5] [8 4 3] [2 4 9]]
Applying amin() function:
[3 3 2]
Applying amin() function again:
[2 4 3]
Applying amax() function:
9
Applying amax() function again:
[8 7 9]
numpy.ptp()
The numpy.ptp() function returns the range (maximum-minimum) of values along an axis.
Live Demo
import numpy as np
a = np.array([[3,7,5],[8,4,3],[2,4,9]])
print ‘Our array is:’
print a
print ‘n’
print ‘Applying ptp() function:’
print np.ptp(a)
print ‘n’
print ‘Applying ptp() function along axis 1:’
print np.ptp(a, axis = 1)
print ‘n’
print ‘Applying ptp() function along axis 0:’
print np.ptp(a, axis = 0)
numpy.percentile()
Percentile (or a centile) is a measure used in statistics indicating the value below which a given percentage of observations in a group of observations fall. The function numpy.percentile() takes the following arguments.
Where,
| Sr.No. | Argument & Description |
| 1 | aInput array |
| 2 | qThe percentile to compute must be between 0-100 |
| 3 | axisThe axis along which the percentile is to be calculated |
A variety of sorting related functions are available in NumPy. These sorting functions implement different sorting algorithms, each of them characterized by the speed of execution, worst-case performance, the workspace required and the stability of algorithms. Following table shows the comparison of three sorting algorithms.
| kind | speed | worst case | work space | stable |
| ‘quicksort’ | 1 | O(n^2) | 0 | no |
| ‘mergesort’ | 2 | O(n*log(n)) | ~n/2 | yes |
| ‘heapsort’ | 3 | O(n*log(n)) | 0 | no |
numpy.sort()
The sort() function returns a sorted copy of the input array. It has the following parameters −
numpy.sort(a, axis, kind, order)
Where,
| Sr.No. | Parameter & Description |
| 1 | aArray to be sorted |
| 2 | axisThe axis along which the array is to be sorted. If none, the array is flattened, sorting on the last axis |
| 3 | kindDefault is quicksort |
| 4 | orderIf the array contains fields, the order of fields to be sorted |
NumPy – Byte Swapping
We have seen that the data stored in the memory of a computer depends on which architecture the CPU uses. It may be little-endian (least significant is stored in the smallest address) or big-endian (most significant byte in the smallest address).
numpy.ndarray.byteswap()
The numpy.ndarray.byteswap() function toggles between the two representations: bigendian and little-endian.
NumPy – Copies & Views
While executing the functions, some of them return a copy of the input array, while some return the view. When the contents are physically stored in another location, it is called Copy. If on the other hand, a different view of the same memory content is provided, we call it as View.
No Copy
Simple assignments do not make the copy of array object. Instead, it uses the same id() of the original array to access it. The id() returns a universal identifier of Python object, similar to the pointer in C.
Furthermore, any changes in either gets reflected in the other. For example, the changing shape of one will change the shape of the other too.
View or Shallow Copy
NumPy has ndarray.view() method which is a new array object that looks at the same data of the original array. Unlike the earlier case, change in dimensions of the new array doesn’t change dimensions of the original.
NumPy – Matrix Library
NumPy package contains a Matrix library numpy.matlib. This module has functions that return matrices instead of ndarray objects.
matlib.empty()
The matlib.empty() function returns a new matrix without initializing the entries. The function takes the following parameters.
numpy.matlib.empty(shape, dtype, order)
Where,
| Sr.No. | Parameter & Description |
| 1 | shapeint or tuple of int defining the shape of the new matrix |
| 2 | DtypeOptional. Data type of the output |
| 3 | orderC or F |
Example
Live Demo
import numpy.matlib
import numpy as np
print np.matlib.empty((2,2))
# filled with random data
It will produce the following output −
[[ 2.12199579e-314, 4.24399158e-314]
[ 4.24399158e-314, 2.12199579e-314]]
numpy.matlib.eye()
This function returns a matrix with 1 along the diagonal elements and the zeros elsewhere. The function takes the following parameters.
numpy.matlib.eye(n, M,k, dtype)
Where,
| Sr.No. | Parameter & Description |
| 1 | nThe number of rows in the resulting matrix |
| 2 | MThe number of columns, defaults to n |
| 3 | kIndex of diagonal |
| 4 | dtypeData type of the output |
Example
Live Demo
import numpy.matlib
import numpy as np
print np.matlib.eye(n = 3, M = 4, k = 0, dtype = float)
It will produce the following output −
[[ 1. 0. 0. 0.]
[ 0. 1. 0. 0.]
[ 0. 0. 1. 0.]]
NumPy – Matplotlib
Matplotlib is a plotting library for Python. It is used along with NumPy to provide an environment that is an effective open-source alternative for MatLab. It can also be used with graphics toolkits like PyQt and wxPython.
Matplotlib module was first written by John D. Hunter. Since 2012, Michael Droettboom is the principal developer. Currently, Matplotlib ver. 1.5.1 is the stable version available. The package is available in binary distribution as well as in the source code form on www.matplotlib.org.
Conventionally, the package is imported into the Python script by adding the following statement −
from matplotlib import pyplot as plt
Here pyplot() is the most important function in matplotlib library, which is used to plot 2D data. The following script plots the equation y = 2x + 5
Example
import numpy as np
from matplotlib import pyplot as plt
x = np.arange(1,11)
y = 2 * x + 5
plt.title(“Matplotlib demo”)
plt.xlabel(“x axis caption”)
plt.ylabel(“y axis caption”)
plt.plot(x,y)
plt.show()
An ndarray object x is created from np.arange() function as the values on the x axis. The corresponding values on the y axis are stored in another ndarray object y. These values are plotted using plot() function of pyplot submodule of matplotlib package.
The graphical representation is displayed by show() function.
The above code should produce the following output −
Instead of the linear graph, the values can be displayed discretely by adding a format string to the plot() function. Following formatting characters can be used.
NumPy – Using Matplotlib
NumPy has a numpy.histogram() function that is a graphical representation of the frequency distribution of data. Rectangles of equal horizontal size corresponding to class interval called bin and variable height corresponding to frequency.
numpy.histogram()
The numpy.histogram() function takes the input array and bins as two parameters. The successive elements in bin array act as the boundary of each bin.
import numpy as np
a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27])
np.histogram(a,bins = [0,20,40,60,80,100])
hist,bins = np.histogram(a,bins = [0,20,40,60,80,100])
print hist
print bins
It will produce the following output −
[3 4 5 2 1] [0 20 40 60 80 100]
plt()
Matplotlib can convert this numeric representation of histogram into a graph. The plt() function of pyplot submodule takes the array containing the data and bin array as parameters and converts into a histogram.
from matplotlib import pyplot as plt
import numpy as np
a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27])
plt.hist(a, bins = [0,20,40,60,80,100])
plt.title(“histogram”)
plt.show()
It should produce the following output –
I/O with NumPy
The ndarray objects can be saved to and loaded from the disk files. The IO functions available are −
- load() and save() functions handle /numPy binary files (with npy extension)
- loadtxt() and savetxt() functions handle normal text files
NumPy introduces a simple file format for ndarray objects. This .npy file stores data, shape, dtype and other information required to reconstruct the ndarray in a disk file such that the array is correctly retrieved even if the file is on another machine with different architecture.
numpy.save()
The numpy.save() file stores the input array in a disk file with npy extension.
import numpy as np
a = np.array([1,2,3,4,5])
np.save(‘outfile’,a)
To reconstruct array from outfile.npy, use load() function.
import numpy as np
b = np.load(‘outfile.npy’)
print b
It will produce the following output −
array([1, 2, 3, 4, 5])
The save() and load() functions accept an additional Boolean parameter allow_pickles. A pickle in Python is used to serialize and de-serialize objects before saving to or reading from a disk file.
savetxt()
The storage and retrieval of array data in simple text file format is done with savetxt() and loadtxt() functions.
Example
import numpy as np
a = np.array([1,2,3,4,5])
np.savetxt(‘out.txt’,a)
b = np.loadtxt(‘out.txt’)
print b
It will produce the following output −
[ 1. 2. 3. 4. 5.] 0
[ad_2]
Source link