StarMirror/data-science-ipython-notebooks
1
0
Fork 0
mirror of https://github.com/donnemartin/data-science-ipython-notebooks.git synced 2024-03-22 13:30:56 +08:00
Code Issues Projects Releases Wiki Activity
91ed7370f9
data-science-ipython-notebooks/numpy/02.10NumPy For Data Analysis.ipynb
Shivendra k jha 91ed7370f9
Add files via upload
2021-01-28 12:03:27 +05:30

2255 lines
48 KiB
Python
Raw Blame History

{
"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",
"<class 'numpy.ndarray'>\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
}
Reference in New Issue View Git Blame Copy Permalink