diff --git a/numpy/02.10NumPy For Data Analysis.ipynb b/numpy/02.10NumPy For Data Analysis.ipynb new file mode 100644 index 0000000..3361ecc --- /dev/null +++ b/numpy/02.10NumPy For Data Analysis.ipynb @@ -0,0 +1,2254 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## What is Numpy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "NumPy is a python library used for working with arrays.\n", + "\n", + "It also has functions for working in domain of linear algebra, fourier transform, and matrices.\n", + "\n", + "NumPy was created in 2005 by Travis Oliphant. It is an open source project and you can use it freely.\n", + "\n", + "NumPy stands for Numerical Python.\n", + "\n", + "Numpy is also incredibly fast, as it has bindings to C libraries. For more info on why you would want to use Arrays instead of lists, check out this great" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Installation Instructions\n", + "\n", + "**It is highly recommended you install Python using the Anaconda distribution to make sure all underlying dependencies (such as Linear Algebra libraries) all sync up with the use of a conda install. If you have Anaconda, install NumPy by going to your terminal or command prompt and typing:**\n", + " \n", + " conda install numpy\n", + " \n", + "**If you do not have Anaconda and can not install it, please refer to [Numpy's official documentation on various installation instructions.](http://docs.scipy.org/doc/numpy-1.10.1/user/install.html)**" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[9, 8, 7]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_list= [9,8,7]\n", + "my_list" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([9, 8, 7])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "np.array(my_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 2, 3, 4, 5])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list1=[1,2,3,4,5]\n", + "np.array(list1)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1, 2, 3], [4, 5, 6], [6, 7, 7]]\n", + "\n", + "\n", + "[[1 2 3]\n", + " [4 5 6]\n", + " [6 7 7]]\n" + ] + } + ], + "source": [ + "matrix=[[1,2,3],[4,5,6],[6,7,7]]\n", + "print(matrix)\n", + "print ('\\n')\n", + "\n", + "print (np.array(matrix))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Built-in Methods\n", + "\n", + "There are lots of built-in ways to generate Arrays" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### NumPy is used to work with arrays. The array object in NumPy is called ndarray." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1 2 3 4 5]\n", + "\n" + ] + } + ], + "source": [ + "arr = np.array([1, 2, 3, 4, 5])\n", + "\n", + "print(arr)\n", + "\n", + "print(type(arr))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", + " 17, 18, 19])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.arange(0,20)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.arange(0,50,3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### linspace\n", + "Return evenly spaced numbers over a specified interval." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0., 10., 20., 30., 40., 50.])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.linspace (0,50,6)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0. , 0.25641026, 0.51282051, 0.76923077, 1.02564103,\n", + " 1.28205128, 1.53846154, 1.79487179, 2.05128205, 2.30769231,\n", + " 2.56410256, 2.82051282, 3.07692308, 3.33333333, 3.58974359,\n", + " 3.84615385, 4.1025641 , 4.35897436, 4.61538462, 4.87179487,\n", + " 5.12820513, 5.38461538, 5.64102564, 5.8974359 , 6.15384615,\n", + " 6.41025641, 6.66666667, 6.92307692, 7.17948718, 7.43589744,\n", + " 7.69230769, 7.94871795, 8.20512821, 8.46153846, 8.71794872,\n", + " 8.97435897, 9.23076923, 9.48717949, 9.74358974, 10. ])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.linspace (0,10,40)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### zeros and ones\n", + "\n", + "Generate arrays of zeros or ones" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.zeros(9)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0., 0., 0., 0.],\n", + " [0., 0., 0., 0.],\n", + " [0., 0., 0., 0.]])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.zeros((3,4))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1., 1., 1., 1.])" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.ones(4)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 1., 1., 1.],\n", + " [1., 1., 1., 1.],\n", + " [1., 1., 1., 1.]])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.ones((3,4))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## eye\n", + "\n", + "Creates an identity matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 0., 0., 0., 0.],\n", + " [0., 1., 0., 0., 0.],\n", + " [0., 0., 1., 0., 0.],\n", + " [0., 0., 0., 1., 0.],\n", + " [0., 0., 0., 0., 1.]])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.eye(5)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 0., 0., 0., 0.],\n", + " [0., 1., 0., 0., 0.],\n", + " [0., 0., 1., 0., 0.],\n", + " [0., 0., 0., 1., 0.]])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.eye(4,5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Random\n", + "### What is a Random Number?\n", + "Random number does NOT mean a different number every time. Random means something that can not be predicted logically." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### rand\n", + "Create an array of the given shape and populate it with\n", + "random samples from a uniform distribution\n", + "over ``[0, 1)``." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.7489597 , 0.78917258, 0.70866872])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.rand(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.54892249, 0.34257905, 0.0378045 , 0.94850873],\n", + " [0.64952372, 0.60916155, 0.02955791, 0.22780147],\n", + " [0.23216998, 0.41829629, 0.53139821, 0.33340072],\n", + " [0.51921418, 0.72563794, 0.38172859, 0.32186366]])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.rand(4,4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### randn\n", + "\n", + "Return a sample (or samples) from the \"standard normal\" distribution. Unlike rand which is uniform:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0.38705145, -0.00165486])" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.randn(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.28120086, 0.68961856, -1.08746915],\n", + " [-0.8188998 , -0.94987156, 0.39145483]])" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.randn(2,3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### randint\n", + "Return random integers from `low` (inclusive) to `high` (exclusive)." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.randint(1,7)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([53, 1, 5, 95, 28, 22, 76, 12, 45, 61])" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.randint(1,100,10)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "15" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.randint (1,111)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Some of the Array Attributes and methods\n", + "\n", + "Have a look some of the main attributes and methods or an array" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "arr = np.arange(50)\n", + "ranarr=np.random.randint (0,100,10)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", + " 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n", + " 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49])" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([60, 44, 98, 38, 27, 97, 75, 53, 10, 40])" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ranarr" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reshape \n", + "Covert existing array into new shape with same data." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9],\n", + " [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],\n", + " [20, 21, 22, 23, 24, 25, 26, 27, 28, 29],\n", + " [30, 31, 32, 33, 34, 35, 36, 37, 38, 39],\n", + " [40, 41, 42, 43, 44, 45, 46, 47, 48, 49]])" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr.reshape(5,10)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,\n", + " 16, 17, 18, 19, 20, 21, 22, 23, 24],\n", + " [25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,\n", + " 41, 42, 43, 44, 45, 46, 47, 48, 49]])" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr.reshape (2,25)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "arr1= np.arange(24)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", + " 17, 18, 19, 20, 21, 22, 23])" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr1" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[ 0, 1, 2, 3],\n", + " [ 4, 5, 6, 7]],\n", + "\n", + " [[ 8, 9, 10, 11],\n", + " [12, 13, 14, 15]],\n", + "\n", + " [[16, 17, 18, 19],\n", + " [20, 21, 22, 23]]])" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr1.reshape(3,2,4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### max,min,argmax,argmin\n", + "\n", + "These are useful methods for finding max or min values. Or to find their index locations using argmin or argmax" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", + " 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n", + " 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49])" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "arr.min()" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "49" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr.max()" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([60, 44, 98, 38, 27, 97, 75, 53, 10, 40])" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ranarr" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "98" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ranarr.max()" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ranarr.argmax()" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ranarr.argmin()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Shape\n", + "The shape property is usually used to get the current shape of an array, but may also be used to reshape the array in-place by assigning a tuple of array dimensions to it" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(50,)" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Shape is an attribute that array have \n", + "# Vector\n", + "arr.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 1, 2, 3, 4],\n", + " [ 5, 6, 7, 8, 9],\n", + " [10, 11, 12, 13, 14],\n", + " [15, 16, 17, 18, 19],\n", + " [20, 21, 22, 23, 24],\n", + " [25, 26, 27, 28, 29],\n", + " [30, 31, 32, 33, 34],\n", + " [35, 36, 37, 38, 39],\n", + " [40, 41, 42, 43, 44],\n", + " [45, 46, 47, 48, 49]])" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Notice the the two set of array\n", + "arr.reshape(10,5)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,\n", + " 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,\n", + " 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n", + " 48, 49]])" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr.reshape (1,50)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(50, 1)" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr.reshape(50,1).shape" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dtype('int32')" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# You Can find the datatype of object in the array \n", + "arr.dtype" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A data type object (an instance of numpy.dtype class) describes how the bytes in the fixed-size block of memory corresponding to an array item should be interpreted. It describes the following aspects of the data:\n", + "\n", + "Type of the data (integer, float, Python object, etc.)\n", + "Size of the data (how many bytes is in e.g. the integer)\n", + "Byte order of the data (little-endian or big-endian)\n", + "If the data type is structured, an aggregate of other data types, (e.g., describing an array item consisting of an integer and a float),\n", + "what are the names of the “fields” of the structure, by which they can be accessed,\n", + "what is the data-type of each field, and\n", + "which part of the memory block each field takes.\n", + "If the data type is a sub-array, what is its shape and data type.\n", + "\n", + "https://docs.scipy.org/doc/numpy-1.13.0/reference/arrays.dtypes.html" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Numpy Indexing and Selection\n", + "We will explore how we are going to grab a prticular elements of an array " + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", + " 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n", + " 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49])" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Bracket Indexing and Selection\n", + "The simplest way to pick one or some elements of an array looks very similar to python lists:" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "24" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Get the value at the index 24\n", + "arr[24]" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]\n", + "\n", + "\n", + "[0 1 2 3 4 5 6 7 8 9]\n" + ] + } + ], + "source": [ + "# Get the value in the range \n", + "print (arr[4:24])\n", + "print ('\\n')\n", + "print (arr[0:10])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Broadcasting\n", + "\n", + "Here Numpy is different from normal List in python since it is having ability to broadcast" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 10, 11, 12, 13, 14, 15, 16,\n", + " 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n", + " 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49])" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Setting the value with index range (Broadcasting)\n", + "arr[0:10]=88\n", + "# Show \n", + "arr" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", + " 17, 18, 19, 20])" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr=np.arange (0,21)\n", + "arr" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Slicing is Very important \n", + "slice_of_arr=arr[0:16]\n", + "#Show slice \n", + "slice_of_arr" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50])" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Change the value of Slice \n", + "slice_of_arr[:]=50\n", + "slice_of_arr" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Note : Now the change is also there in original array " + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 16,\n", + " 17, 18, 19, 20])" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Data is not copied, it's a view of the original array! This avoids memory problems!" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 16,\n", + " 17, 18, 19, 20])" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# To get a copy , need to be explicit \n", + "arr_copy=arr.copy ()\n", + "arr_copy " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Indexing & Selection for 2D Array(Matrix)\n", + "Two-dimensional (2D) arrays are indexed by two subscripts, one for the row and one for the column. Each element in the 2D array must by the same type, either a primitive type or object type.\n", + "\n", + "\n", + "The general format is arr_2d[row][col] or arr_2d[row,col]. I recommend usually using the comma notation for clarity." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 2, 3],\n", + " [4, 5, 6],\n", + " [7, 8, 9]])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "matrix= np.array(([1,2,3],[4,5,6],[7,8,9]))\n", + "# Show the value \n", + "matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([7, 8, 9])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Indexing Rows \n", + "# Grab 3nd row\n", + "matrix[2]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[2],\n", + " [5],\n", + " [8]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#row[1][2] #row[1,2]\n", + "# Indexing Column \n", + "# Grab 2nd column \n", + "matrix[0:,1:2]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Format is arr_2d[row][col] or arr_2d[row,col]\n", + "\n", + "# Getting individual element value\n", + "matrix[1][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "matrix[1][2]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Getting individual element value\n", + "matrix[1,0]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 2, 3],\n", + " [4, 5, 6],\n", + " [7, 8, 9]])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 2],\n", + " [4, 5]])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Matrix slicing \n", + "# Shape (2,2) from top left corner \n", + "matrix[0:2,0:2]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[2, 3],\n", + " [5, 6]])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Matrix slicing \n", + "# Shape (2,2) from top right corner \n", + "matrix[0:2,1:3]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[5, 6],\n", + " [8, 9]])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Matrix slicing \n", + "# Shape (2,2) from bottom right corner \n", + "matrix[1:,1:]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "arr=np.arange(25)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "b=arr.reshape(5,5)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 1, 2, 3, 4],\n", + " [ 5, 6, 7, 8, 9],\n", + " [10, 11, 12, 13, 14],\n", + " [15, 16, 17, 18, 19],\n", + " [20, 21, 22, 23, 24]])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[18, 19],\n", + " [23, 24]])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b[3:,3:]" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 3],\n", + " [ 8],\n", + " [13],\n", + " [18],\n", + " [23]])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Grab all the elements in 4th column\n", + "b[0:,3:4]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fancing Indexing \n", + "Fancy indexing is conceptually simple: it means passing an array of indices to access multiple array elements at once.\n", + "\n", + "lets see an example " + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Set up matrix \n", + "matrix1 = np.zeros ((11,11))\n", + "# Length of matrix\n", + "matrix1_length = matrix1.shape[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n", + " [ 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n", + " [ 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.],\n", + " [ 6., 6., 6., 6., 6., 6., 6., 6., 6., 6., 6.],\n", + " [ 8., 8., 8., 8., 8., 8., 8., 8., 8., 8., 8.],\n", + " [10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10.],\n", + " [12., 12., 12., 12., 12., 12., 12., 12., 12., 12., 12.],\n", + " [14., 14., 14., 14., 14., 14., 14., 14., 14., 14., 14.],\n", + " [16., 16., 16., 16., 16., 16., 16., 16., 16., 16., 16.],\n", + " [18., 18., 18., 18., 18., 18., 18., 18., 18., 18., 18.],\n", + " [20., 20., 20., 20., 20., 20., 20., 20., 20., 20., 20.]])" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "for i in range (matrix1_length):\n", + " matrix1[i]+=i\n", + "matrix1" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.],\n", + " [ 6., 6., 6., 6., 6., 6., 6., 6., 6., 6., 6.],\n", + " [ 8., 8., 8., 8., 8., 8., 8., 8., 8., 8., 8.],\n", + " [10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10.]])" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Fancy Indexing allows The following \n", + "matrix1[[2,3,4,5]]" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[10., 10., 10., 10., 10., 10., 10., 10., 10., 10., 10.],\n", + " [12., 12., 12., 12., 12., 12., 12., 12., 12., 12., 12.],\n", + " [14., 14., 14., 14., 14., 14., 14., 14., 14., 14., 14.],\n", + " [16., 16., 16., 16., 16., 16., 16., 16., 16., 16., 16.]])" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "matrix1[[5,6,7,8]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## More Indexing Help\n", + "Indexing a 2d matrix can be a bit confusing at first, especially when you start to add in step size. Try google image searching NumPy indexing to fins useful images, like this one:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "## Selection\n", + "\n", + "Let's briefly go over how to use brackets for selection based off of comparison operators." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,\n", + " 18, 19, 20, 21])" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr = np.arange(1,22)\n", + "arr" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([False, False, False, False, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True])" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr>4" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "bool_arr= arr>5" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([False, False, False, False, False, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True,\n", + " True, True, True])" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bool_arr" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21])" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr[bool_arr]" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,\n", + " 21])" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr[arr>3]" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21])" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x=6\n", + "arr[arr>x]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## NumPy Operations\n", + "\n", + "### Arithmetic \n", + "Arithmetic Operations. 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.\n", + "\n", + "You Can easily perform array with array arithematic , or scalar with array arithematic \n", + "\n", + "lets see some examples \n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "arr= np.arange (0,25)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", + " 17, 18, 19, 20, 21, 22, 23, 24])" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32,\n", + " 34, 36, 38, 40, 42, 44, 46, 48])" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr+arr" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144,\n", + " 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576])" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr*arr" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0])" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr-arr" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\pskj0\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:3: RuntimeWarning: invalid value encountered in true_divide\n", + " This is separate from the ipykernel package so we can avoid doing imports until\n" + ] + }, + { + "data": { + "text/plain": [ + "array([nan, 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", + " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])" + ] + }, + "execution_count": 147, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Warning on division by zero, but not an error!\n", + "# Just replaced with nan\n", + "arr/arr" + ] + }, + { + "cell_type": "code", + "execution_count": 148, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\pskj0\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:2: RuntimeWarning: divide by zero encountered in true_divide\n", + " \n" + ] + }, + { + "data": { + "text/plain": [ + "array([ inf, 1. , 0.5 , 0.33333333, 0.25 ,\n", + " 0.2 , 0.16666667, 0.14285714, 0.125 , 0.11111111,\n", + " 0.1 , 0.09090909, 0.08333333, 0.07692308, 0.07142857,\n", + " 0.06666667, 0.0625 , 0.05882353, 0.05555556, 0.05263158,\n", + " 0.05 , 0.04761905, 0.04545455, 0.04347826, 0.04166667])" + ] + }, + "execution_count": 148, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Also warning, but not an error instead infinity\n", + "1/arr" + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 1, 8, 27, 64, 125, 216, 343, 512,\n", + " 729, 1000, 1331, 1728, 2197, 2744, 3375, 4096, 4913,\n", + " 5832, 6859, 8000, 9261, 10648, 12167, 13824], dtype=int32)" + ] + }, + "execution_count": 149, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr**3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Universal Array Functions\n", + "\n", + "Numpy comes with many [universal array functions](http://docs.scipy.org/doc/numpy/reference/ufuncs.html), which are essentially just mathematical operations you can use to perform the operation across the array. Let's show some common ones:" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0. , 1. , 1.41421356, 1.73205081, 2. ,\n", + " 2.23606798, 2.44948974, 2.64575131, 2.82842712, 3. ,\n", + " 3.16227766, 3.31662479, 3.46410162, 3.60555128, 3.74165739,\n", + " 3.87298335, 4. , 4.12310563, 4.24264069, 4.35889894,\n", + " 4.47213595, 4.58257569, 4.69041576, 4.79583152, 4.89897949])" + ] + }, + "execution_count": 150, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Taking square Roots \n", + "np.sqrt (arr)" + ] + }, + { + "cell_type": "code", + "execution_count": 151, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "24" + ] + }, + "execution_count": 151, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.max(arr) " + ] + }, + { + "cell_type": "code", + "execution_count": 152, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1.00000000e+00, 2.71828183e+00, 7.38905610e+00, 2.00855369e+01,\n", + " 5.45981500e+01, 1.48413159e+02, 4.03428793e+02, 1.09663316e+03,\n", + " 2.98095799e+03, 8.10308393e+03, 2.20264658e+04, 5.98741417e+04,\n", + " 1.62754791e+05, 4.42413392e+05, 1.20260428e+06, 3.26901737e+06,\n", + " 8.88611052e+06, 2.41549528e+07, 6.56599691e+07, 1.78482301e+08,\n", + " 4.85165195e+08, 1.31881573e+09, 3.58491285e+09, 9.74480345e+09,\n", + " 2.64891221e+10])" + ] + }, + "execution_count": 152, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Calculating exponential (e^)\n", + "np.exp(arr)" + ] + }, + { + "cell_type": "code", + "execution_count": 153, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "24" + ] + }, + "execution_count": 153, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.max(arr) #same as arr.max()" + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0. , 0.84147098, 0.90929743, 0.14112001, -0.7568025 ,\n", + " -0.95892427, -0.2794155 , 0.6569866 , 0.98935825, 0.41211849,\n", + " -0.54402111, -0.99999021, -0.53657292, 0.42016704, 0.99060736,\n", + " 0.65028784, -0.28790332, -0.96139749, -0.75098725, 0.14987721,\n", + " 0.91294525, 0.83665564, -0.00885131, -0.8462204 , -0.90557836])" + ] + }, + "execution_count": 154, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sin(arr)" + ] + }, + { + "cell_type": "code", + "execution_count": 155, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\pskj0\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:1: RuntimeWarning: divide by zero encountered in log\n", + " \"\"\"Entry point for launching an IPython kernel.\n" + ] + }, + { + "data": { + "text/plain": [ + "array([ -inf, 0. , 0.69314718, 1.09861229, 1.38629436,\n", + " 1.60943791, 1.79175947, 1.94591015, 2.07944154, 2.19722458,\n", + " 2.30258509, 2.39789527, 2.48490665, 2.56494936, 2.63905733,\n", + " 2.7080502 , 2.77258872, 2.83321334, 2.89037176, 2.94443898,\n", + " 2.99573227, 3.04452244, 3.09104245, 3.13549422, 3.17805383])" + ] + }, + "execution_count": 155, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.log(arr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Some Valueble insight of numpy lot more to explore \n", + "https://numpy.org/" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}