Category: numpy

NumPy – Byte Swapping ”; Previous Next 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. Live Demo import numpy as np a = np.array([1, 256, 8755], dtype = np.int16) print ”Our array is:” print a print ”Representation of data in memory in hexadecimal form:” print map(hex,a) # byteswap() function swaps in place by passing True parameter print ”Applying byteswap() function:” print a.byteswap(True) print ”In hexadecimal form:” print map(hex,a) # We can see the bytes being swapped It will produce the following output − Our array is: [1 256 8755] Representation of data in memory in hexadecimal form: [”0x1”, ”0x100”, ”0x2233”] Applying byteswap() function: [256 1 13090] In hexadecimal form: [”0x100”, ”0x1”, ”0x3322”] Print Page Previous Next Advertisements ”;

NumPy – Arithmetic Operations ”; Previous Next Input arrays for performing arithmetic operations such as add(), subtract(), multiply(), and divide() must be either of the same shape or should conform to array broadcasting rules. Example Live Demo import numpy as np a = np.arange(9, dtype = np.float_).reshape(3,3) print ”First array:” print a print ”n” print ”Second array:” b = np.array([10,10,10]) print b print ”n” print ”Add the two arrays:” print np.add(a,b) print ”n” print ”Subtract the two arrays:” print np.subtract(a,b) print ”n” print ”Multiply the two arrays:” print np.multiply(a,b) print ”n” print ”Divide the two arrays:” print np.divide(a,b) It will produce the following output − First array: [[ 0. 1. 2.] [ 3. 4. 5.] [ 6. 7. 8.]] Second array: [10 10 10] Add the two arrays: [[ 10. 11. 12.] [ 13. 14. 15.] [ 16. 17. 18.]] Subtract the two arrays: [[-10. -9. -8.] [ -7. -6. -5.] [ -4. -3. -2.]] Multiply the two arrays: [[ 0. 10. 20.] [ 30. 40. 50.] [ 60. 70. 80.]] Divide the two arrays: [[ 0. 0.1 0.2] [ 0.3 0.4 0.5] [ 0.6 0.7 0.8]] Let us now discuss some of the other important arithmetic functions available in NumPy. numpy.reciprocal() This function returns the reciprocal of argument, element-wise. For elements with absolute values larger than 1, the result is always 0 because of the way in which Python handles integer division. For integer 0, an overflow warning is issued. Example Live Demo import numpy as np a = np.array([0.25, 1.33, 1, 0, 100]) print ”Our array is:” print a print ”n” print ”After applying reciprocal function:” print np.reciprocal(a) print ”n” b = np.array([100], dtype = int) print ”The second array is:” print b print ”n” print ”After applying reciprocal function:” print np.reciprocal(b) It will produce the following output − Our array is: [ 0.25 1.33 1. 0. 100. ] After applying reciprocal function: main.py:9: RuntimeWarning: divide by zero encountered in reciprocal print np.reciprocal(a) [ 4. 0.7518797 1. inf 0.01 ] The second array is: [100] After applying reciprocal function: [0] numpy.power() This function treats elements in the first input array as base and returns it raised to the power of the corresponding element in the second input array. Live Demo import numpy as np a = np.array([10,100,1000]) print ”Our array is:” print a print ”n” print ”Applying power function:” print np.power(a,2) print ”n” print ”Second array:” b = np.array([1,2,3]) print b print ”n” print ”Applying power function again:” print np.power(a,b) It will produce the following output − Our array is: [ 10 100 1000] Applying power function: [ 100 10000 1000000] Second array: [1 2 3] Applying power function again: [ 10 10000 1000000000] numpy.mod() This function returns the remainder of division of the corresponding elements in the input array. The function numpy.remainder() also produces the same result. Live Demo import numpy as np a = np.array([10,20,30]) b = np.array([3,5,7]) print ”First array:” print a print ”n” print ”Second array:” print b print ”n” print ”Applying mod() function:” print np.mod(a,b) print ”n” print ”Applying remainder() function:” print np.remainder(a,b) It will produce the following output − First array: [10 20 30] Second array: [3 5 7] Applying mod() function: [1 0 2] Applying remainder() function: [1 0 2] The following functions are used to perform operations on array with complex numbers. numpy.real() − returns the real part of the complex data type argument. numpy.imag() − returns the imaginary part of the complex data type argument. numpy.conj() − returns the complex conjugate, which is obtained by changing the sign of the imaginary part. numpy.angle() − returns the angle of the complex argument. The function has degree parameter. If true, the angle in the degree is returned, otherwise the angle is in radians. Live Demo import numpy as np a = np.array([-5.6j, 0.2j, 11. , 1+1j]) print ”Our array is:” print a print ”n” print ”Applying real() function:” print np.real(a) print ”n” print ”Applying imag() function:” print np.imag(a) print ”n” print ”Applying conj() function:” print np.conj(a) print ”n” print ”Applying angle() function:” print np.angle(a) print ”n” print ”Applying angle() function again (result in degrees)” print np.angle(a, deg = True) It will produce the following output − Our array is: [ 0.-5.6j 0.+0.2j 11.+0.j 1.+1.j ] Applying real() function: [ 0. 0. 11. 1.] Applying imag() function: [-5.6 0.2 0. 1. ] Applying conj() function: [ 0.+5.6j 0.-0.2j 11.-0.j 1.-1.j ] Applying angle() function: [-1.57079633 1.57079633 0. 0.78539816] Applying angle() function again (result in degrees) [-90. 90. 0. 45.] Print Page Previous Next Advertisements ”;

NumPy – Indexing & Slicing ”; Previous Next 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] In 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. Example 6 Live Demo 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:] The output is as follows − [[1 2 3] [3 4 5] [4 5 6]] Now we will slice the array from the index a[1:] [[3 4 5] [4 5 6]] Slicing can also include ellipsis (…) to make a selection tuple of the same length as the dimension of an array. If ellipsis is used at the row position, it will return an ndarray comprising of items in rows. Example 7 Live Demo # array to begin with import numpy as np a = np.array([[1,2,3],[3,4,5],[4,5,6]]) print ”Our array is:” print a print ”n” # this returns array of items in the second column print ”The items in the second column are:” print a[…,1] print ”n” # Now we will slice all items from the second row print ”The items in the second row are:” print a[1,…] print ”n” # Now we will slice all items from column 1 onwards print ”The items column 1 onwards are:” print a[…,1:] The output of this program is as follows − Our array is: [[1 2 3] [3 4 5] [4 5 6]] The items in the second column are: [2 4 5] The items in the second row are: [3 4 5] The items column 1 onwards are: [[2 3] [4 5] [5 6]] Print Page Previous Next Advertisements ”;

NumPy – Iterating Over Array ”; Previous Next 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 arange() function and iterate over it using nditer. Example 1 Live Demo import numpy as np a = np.arange(0,60,5) a = a.reshape(3,4) print ”Original array is:” print a print ”n” print ”Modified array is:” for x in np.nditer(a): print x, The output of this program is as follows − Original array is: [[ 0 5 10 15] [20 25 30 35] [40 45 50 55]] Modified array is: 0 5 10 15 20 25 30 35 40 45 50 55 Example 2 The order of iteration is chosen to match the memory layout of an array, without considering a particular ordering. This can be seen by iterating over the transpose of the above array. Live Demo import numpy as np a = np.arange(0,60,5) a = a.reshape(3,4) print ”Original array is:” print a print ”n” print ”Transpose of the original array is:” b = a.T print b print ”n” print ”Modified array is:” for x in np.nditer(b): print x, The output of the above program is as follows − Original array is: [[ 0 5 10 15] [20 25 30 35] [40 45 50 55]] Transpose of the original array is: [[ 0 20 40] [ 5 25 45] [10 30 50] [15 35 55]] Modified array is: 0 5 10 15 20 25 30 35 40 45 50 55 Iteration Order If the same elements are stored using F-style order, the iterator chooses the more efficient way of iterating over an array. Example 1 Live Demo import numpy as np a = np.arange(0,60,5) a = a.reshape(3,4) print ”Original array is:” print a print ”n” print ”Transpose of the original array is:” b = a.T print b print ”n” print ”Sorted in C-style order:” c = b.copy(order = ”C”) print c for x in np.nditer(c): print x, print ”n” print ”Sorted in F-style order:” c = b.copy(order = ”F”) print c for x in np.nditer(c): print x, Its output would be as follows − Original array is: [[ 0 5 10 15] [20 25 30 35] [40 45 50 55]] Transpose of the original array is: [[ 0 20 40] [ 5 25 45] [10 30 50] [15 35 55]] Sorted in C-style order: [[ 0 20 40] [ 5 25 45] [10 30 50] [15 35 55]] 0 20 40 5 25 45 10 30 50 15 35 55 Sorted in F-style order: [[ 0 20 40] [ 5 25 45] [10 30 50] [15 35 55]] 0 5 10 15 20 25 30 35 40 45 50 55 Example 2 It is possible to force nditer object to use a specific order by explicitly mentioning it. Live Demo import numpy as np a = np.arange(0,60,5) a = a.reshape(3,4) print ”Original array is:” print a print ”n” print ”Sorted in C-style order:” for x in np.nditer(a, order = ”C”): print x, print ”n” print ”Sorted in F-style order:” for x in np.nditer(a, order = ”F”): print x, Its output would be − Original array is: [[ 0 5 10 15] [20 25 30 35] [40 45 50 55]] Sorted in C-style order: 0 5 10 15 20 25 30 35 40 45 50 55 Sorted in F-style order: 0 20 40 5 25 45 10 30 50 15 35 55 Modifying Array Values The nditer object has another optional parameter called op_flags. Its default value is read-only, but can be set to read-write or write-only mode. This will enable modifying array elements using this iterator. Example Live Demo import numpy as np a = np.arange(0,60,5) a = a.reshape(3,4) print ”Original array is:” print a print ”n” for x in np.nditer(a, op_flags = [”readwrite”]): x[…] = 2*x print ”Modified array is:” print a Its output is as follows − Original array is: [[ 0 5 10 15] [20 25 30 35] [40 45 50 55]] Modified array is: [[ 0 10 20 30] [ 40 50 60 70] [ 80 90 100 110]] External Loop The nditer class constructor has a ‘flags’ parameter, which can take the following values − Sr.No. Parameter & Description 1 c_index C_order index can be tracked 2 f_index Fortran_order index is tracked 3 multi-index Type of indexes with one per iteration can be tracked 4 external_loop Causes values given to be one-dimensional arrays with multiple values instead of zero-dimensional array Example In the following example, one-dimensional arrays corresponding to each column is traversed by the iterator. Live Demo import numpy as np a = np.arange(0,60,5) a = a.reshape(3,4) print ”Original array is:” print a print ”n” print ”Modified array is:” for x in np.nditer(a, flags = [”external_loop”], order = ”F”): print x, The output is as follows − Original array is: [[ 0 5 10 15] [20 25 30 35] [40 45 50 55]] Modified array is: [ 0 20 40] [ 5 25 45] [10 30 50] [15 35 55] Broadcasting Iteration If two arrays are broadcastable, a combined nditer object is able to iterate upon them concurrently. Assuming that an array a has dimension 3X4, and there is another array b of dimension 1X4, the iterator of following type is used (array b is broadcast to size of a). Example Live Demo import numpy as np a = np.arange(0,60,5) a = a.reshape(3,4) print ”First array is:” print a print ”n” print ”Second array is:” b = np.array([1, 2, 3, 4], dtype = int) print b print ”n” print ”Modified array is:” for x,y in np.nditer([a,b]): print “%d:%d” % (x,y), Its output would be as follows − First array is: [[ 0 5 10 15] [20 25 30 35] [40 45 50 55]] Second array is: [1 2 3 4] Modified array is: 0:1 5:2 10:3 15:4 20:1 25:2 30:3

NumPy – Data Types ”; Previous Next NumPy supports a much greater variety of numerical types than Python does. The following table shows different scalar data types defined in NumPy. Sr.No. Data Types & Description 1 bool_ Boolean (True or False) stored as a byte 2 int_ Default integer type (same as C long; normally either int64 or int32) 3 intc Identical to C int (normally int32 or int64) 4 intp Integer used for indexing (same as C ssize_t; normally either int32 or int64) 5 int8 Byte (-128 to 127) 6 int16 Integer (-32768 to 32767) 7 int32 Integer (-2147483648 to 2147483647) 8 int64 Integer (-9223372036854775808 to 9223372036854775807) 9 uint8 Unsigned integer (0 to 255) 10 uint16 Unsigned integer (0 to 65535) 11 uint32 Unsigned integer (0 to 4294967295) 12 uint64 Unsigned integer (0 to 18446744073709551615) 13 float_ Shorthand for float64 14 float16 Half precision float: sign bit, 5 bits exponent, 10 bits mantissa 15 float32 Single precision float: sign bit, 8 bits exponent, 23 bits mantissa 16 float64 Double precision float: sign bit, 11 bits exponent, 52 bits mantissa 17 complex_ Shorthand for complex128 18 complex64 Complex number, represented by two 32-bit floats (real and imaginary components) 19 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 interpretation of 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 data type is a subarray, its shape and data type The byte order is decided by prefixing ”<” or ”>” to data type. ”<” means that encoding is little-endian (least significant is stored in smallest address). ”>” means that encoding is big-endian (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 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 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,)] Example 6 Live Demo # file name can be used to access content of age column import numpy as np dt = np.dtype([(”age”,np.int8)]) a = np.array([(10,),(20,),(30,)], dtype = dt) print a[”age”] The output is as follows − [10 20 30] Example 7 The following examples define a structured data type called student with a string field ”name”, an integer field ”age” and a float field ”marks”. This dtype is applied to ndarray object. Live Demo import numpy as np student = np.dtype([(”name”,”S20”), (”age”, ”i1”), (”marks”, ”f4”)]) print student The output is as follows − [(”name”, ”S20”), (”age”, ”i1”), (”marks”, ”<f4”)]) Example 8 Live Demo import numpy as np student = np.dtype([(”name”,”S20”), (”age”, ”i1”), (”marks”, ”f4”)]) a = np.array([(”abc”, 21, 50),(”xyz”, 18, 75)], dtype = student) print a The output is as follows − [(”abc”, 21, 50.0), (”xyz”, 18, 75.0)] 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) Print Page Previous Next Advertisements ”;

NumPy – Broadcasting ”; Previous Next 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 Live Demo 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 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 program shows an example of broadcasting. Example 2 Live Demo 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 The output of this program would be as follows − First array: [[ 0. 0. 0.] [ 10. 10. 10.] [ 20. 20. 20.] [ 30. 30. 30.]] Second array: [ 1. 2. 3.] First Array + Second Array [[ 1. 2. 3.] [ 11. 12. 13.] [ 21. 22. 23.] [ 31. 32. 33.]] The following figure demonstrates how array b is broadcast to become compatible with a. Print Page Previous Next Advertisements ”;

Discuss NumPy ”; Previous Next 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. This tutorial explains the basics of NumPy such as its architecture and environment. It also discusses the various array functions, types of indexing, etc. An introduction to Matplotlib is also provided. All this is explained with the help of examples for better understanding. Print Page Previous Next Advertisements ”;

NumPy – Mathematical Functions ”; Previous Next 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. Example Live Demo import numpy as np a = np.array([0,30,45,60,90]) print ”Array containing sine values:” sin = np.sin(a*np.pi/180) print sin print ”n” print ”Compute sine inverse of angles. Returned values are in radians.” inv = np.arcsin(sin) print inv print ”n” print ”Check result by converting to degrees:” print np.degrees(inv) print ”n” print ”arccos and arctan functions behave similarly:” cos = np.cos(a*np.pi/180) print cos print ”n” print ”Inverse of cos:” inv = np.arccos(cos) print inv print ”n” print ”In degrees:” print np.degrees(inv) print ”n” print ”Tan function:” tan = np.tan(a*np.pi/180) print tan print ”n” print ”Inverse of tan:” inv = np.arctan(tan) print inv print ”n” print ”In degrees:” print np.degrees(inv) Its output is as follows − Array containing sine values: [ 0. 0.5 0.70710678 0.8660254 1. ] Compute sine inverse of angles. Returned values are in radians. [ 0. 0.52359878 0.78539816 1.04719755 1.57079633] Check result by converting to degrees: [ 0. 30. 45. 60. 90.] arccos and arctan functions behave similarly: [ 1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01 6.12323400e-17] Inverse of cos: [ 0. 0.52359878 0.78539816 1.04719755 1.57079633] In degrees: [ 0. 30. 45. 60. 90.] Tan function: [ 0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00 1.63312394e+16] Inverse of tan: [ 0. 0.52359878 0.78539816 1.04719755 1.57079633] In degrees: [ 0. 30. 45. 60. 90.] 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 a Input data 2 decimals The number of decimals to round to. Default is 0. If negative, the integer is rounded to position to the left of the decimal point Example Live Demo import numpy as np a = np.array([1.0,5.55, 123, 0.567, 25.532]) print ”Original array:” print a print ”n” print ”After rounding:” print np.around(a) print np.around(a, decimals = 1) print np.around(a, decimals = -1) It produces the following output − Original array: [ 1. 5.55 123. 0.567 25.532] After rounding: [ 1. 6. 123. 1. 26. ] [ 1. 5.6 123. 0.6 25.5] [ 0. 10. 120. 0. 30. ] numpy.floor() This function returns the largest integer not greater than the input parameter. The floor of the scalar x is the largest integer i, such that i <= x. Note that in Python, flooring always is rounded away from 0. Example Live Demo import numpy as np a = np.array([-1.7, 1.5, -0.2, 0.6, 10]) print ”The given array:” print a print ”n” print ”The modified array:” print np.floor(a) It produces the following output − The given array: [ -1.7 1.5 -0.2 0.6 10. ] The modified array: [ -2. 1. -1. 0. 10.] numpy.ceil() The ceil() function returns the ceiling of an input value, i.e. the ceil of the scalar x is the smallest integer i, such that i >= x. Example Live Demo import numpy as np a = np.array([-1.7, 1.5, -0.2, 0.6, 10]) print ”The given array:” print a print ”n” print ”The modified array:” print np.ceil(a) It will produce the following output − The given array: [ -1.7 1.5 -0.2 0.6 10. ] The modified array: [ -1. 2. -0. 1. 10.] Print Page Previous Next Advertisements ”;

NumPy – String Functions ”; Previous Next The following functions are used to perform vectorized string operations for arrays of dtype numpy.string_ or numpy.unicode_. They are based on the standard string functions in Python”s built-in library. Sr.No. Function & Description 1 add() Returns element-wise string concatenation for two arrays of str or Unicode 2 multiply() Returns the string with multiple concatenation, element-wise 3 center() Returns a copy of the given string with elements centered in a string of specified length 4 capitalize() Returns a copy of the string with only the first character capitalized 5 title() Returns the element-wise title cased version of the string or unicode 6 lower() Returns an array with the elements converted to lowercase 7 upper() Returns an array with the elements converted to uppercase 8 split() Returns a list of the words in the string, using separatordelimiter 9 splitlines() Returns a list of the lines in the element, breaking at the line boundaries 10 strip() Returns a copy with the leading and trailing characters removed 11 join() Returns a string which is the concatenation of the strings in the sequence 12 replace() Returns a copy of the string with all occurrences of substring replaced by the new string 13 decode() Calls str.decode element-wise 14 encode() Calls str.encode element-wise These functions are defined in character array class (numpy.char). The older Numarray package contained chararray class. The above functions in numpy.char class are useful in performing vectorized string operations. Print Page Previous Next Advertisements ”;

NumPy – Histogram Using Matplotlib ”; Previous Next 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 − Print Page Previous Next Advertisements ”;