numpy/numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Author: Asabeneh Yetayeh\n",
    "\n",
    "# Numpy(Numberic Python)\n",
    "\n",
    "In this note book you will cover all what you need to know about Numpy. Inditon to numpy we will see how to use matplot lib python library which will help us to draw graphs and visualize data.\n",
    "\n",
    "So far, we have been using vscode but from now on I would recommend using Jupter Notebook. To access jupter notebook let's install [anaconda](https://www.anaconda.com/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Installation anconda numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to import numpy (Numeric Python)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A numpy array must have all items to be of the same data type, unlike lists.\n",
    "# This is another significant difference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# How to import numpy\n",
    "import numpy as np\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to check package version in python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numpy: 1.17.2\n"
     ]
    }
   ],
   "source": [
    "# How to check the version of the numpy package\n",
    "print('numpy:', np.__version__)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ALLOW_THREADS', 'AxisError', 'BUFSIZE', 'CLIP', 'ComplexWarning', 'DataSource', 'ERR_CALL', 'ERR_DEFAULT', 'ERR_IGNORE', 'ERR_LOG', 'ERR_PRINT', 'ERR_RAISE', 'ERR_WARN', 'FLOATING_POINT_SUPPORT', 'FPE_DIVIDEBYZERO', 'FPE_INVALID', 'FPE_OVERFLOW', 'FPE_UNDERFLOW', 'False_', 'Inf', 'Infinity', 'MAXDIMS', 'MAY_SHARE_BOUNDS', 'MAY_SHARE_EXACT', 'MachAr', 'ModuleDeprecationWarning', 'NAN', 'NINF', 'NZERO', 'NaN', 'PINF', 'PZERO', 'RAISE', 'RankWarning', 'SHIFT_DIVIDEBYZERO', 'SHIFT_INVALID', 'SHIFT_OVERFLOW', 'SHIFT_UNDERFLOW', 'ScalarType', 'Tester', 'TooHardError', 'True_', 'UFUNC_BUFSIZE_DEFAULT', 'UFUNC_PYVALS_NAME', 'VisibleDeprecationWarning', 'WRAP', '_NoValue', '_UFUNC_API', '__NUMPY_SETUP__', '__all__', '__builtins__', '__cached__', '__config__', '__doc__', '__file__', '__git_revision__', '__loader__', '__mkl_version__', '__name__', '__package__', '__path__', '__spec__', '__version__', '_add_newdoc_ufunc', '_distributor_init', '_globals', '_mat', '_pytesttester', 'abs', 'absolute', 'absolute_import', 'add', 'add_docstring', 'add_newdoc', 'add_newdoc_ufunc', 'alen', 'all', 'allclose', 'alltrue', 'amax', 'amin', 'angle', 'any', 'append', 'apply_along_axis', 'apply_over_axes', 'arange', 'arccos', 'arccosh', 'arcsin', 'arcsinh', 'arctan', 'arctan2', 'arctanh', 'argmax', 'argmin', 'argpartition', 'argsort', 'argwhere', 'around', 'array', 'array2string', 'array_equal', 'array_equiv', 'array_repr', 'array_split', 'array_str', 'asanyarray', 'asarray', 'asarray_chkfinite', 'ascontiguousarray', 'asfarray', 'asfortranarray', 'asmatrix', 'asscalar', 'atleast_1d', 'atleast_2d', 'atleast_3d', 'average', 'bartlett', 'base_repr', 'binary_repr', 'bincount', 'bitwise_and', 'bitwise_not', 'bitwise_or', 'bitwise_xor', 'blackman', 'block', 'bmat', 'bool', 'bool8', 'bool_', 'broadcast', 'broadcast_arrays', 'broadcast_to', 'busday_count', 'busday_offset', 'busdaycalendar', 'byte', 'byte_bounds', 'bytes0', 'bytes_', 'c_', 'can_cast', 'cast', 'cbrt', 'cdouble', 'ceil', 'cfloat', 'char', 'character', 'chararray', 'choose', 'clip', 'clongdouble', 'clongfloat', 'column_stack', 'common_type', 'compare_chararrays', 'compat', 'complex', 'complex128', 'complex256', 'complex64', 'complex_', 'complexfloating', 'compress', 'concatenate', 'conj', 'conjugate', 'convolve', 'copy', 'copysign', 'copyto', 'core', 'corrcoef', 'correlate', 'cos', 'cosh', 'count_nonzero', 'cov', 'cross', 'csingle', 'ctypeslib', 'cumprod', 'cumproduct', 'cumsum', 'datetime64', 'datetime_as_string', 'datetime_data', 'deg2rad', 'degrees', 'delete', 'deprecate', 'deprecate_with_doc', 'diag', 'diag_indices', 'diag_indices_from', 'diagflat', 'diagonal', 'diff', 'digitize', 'disp', 'divide', 'division', 'divmod', 'dot', 'double', 'dsplit', 'dstack', 'dtype', 'dual', 'e', 'ediff1d', 'einsum', 'einsum_path', 'emath', 'empty', 'empty_like', 'equal', 'errstate', 'euler_gamma', 'exp', 'exp2', 'expand_dims', 'expm1', 'extract', 'eye', 'fabs', 'fastCopyAndTranspose', 'fft', 'fill_diagonal', 'find_common_type', 'finfo', 'fix', 'flatiter', 'flatnonzero', 'flexible', 'flip', 'fliplr', 'flipud', 'float', 'float128', 'float16', 'float32', 'float64', 'float_', 'float_power', 'floating', 'floor', 'floor_divide', 'fmax', 'fmin', 'fmod', 'format_float_positional', 'format_float_scientific', 'format_parser', 'frexp', 'frombuffer', 'fromfile', 'fromfunction', 'fromiter', 'frompyfunc', 'fromregex', 'fromstring', 'full', 'full_like', 'fv', 'gcd', 'generic', 'genfromtxt', 'geomspace', 'get_array_wrap', 'get_include', 'get_printoptions', 'getbufsize', 'geterr', 'geterrcall', 'geterrobj', 'gradient', 'greater', 'greater_equal', 'half', 'hamming', 'hanning', 'heaviside', 'histogram', 'histogram2d', 'histogram_bin_edges', 'histogramdd', 'hsplit', 'hstack', 'hypot', 'i0', 'identity', 'iinfo', 'imag', 'in1d', 'index_exp', 'indices', 'inexact', 'inf', 'info', 'infty', 'inner', 'insert', 'int', 'int0', 'int16', 'int32', 'int64', 'int8', 'int_', 'int_asbuffer', 'intc', 'integer', 'interp', 'intersect1d', 'intp', 'invert', 'ipmt', 'irr', 'is_busday', 'isclose', 'iscomplex', 'iscomplexobj', 'isfinite', 'isfortran', 'isin', 'isinf', 'isnan', 'isnat', 'isneginf', 'isposinf', 'isreal', 'isrealobj', 'isscalar', 'issctype', 'issubclass_', 'issubdtype', 'issubsctype', 'iterable', 'ix_', 'kaiser', 'kron', 'lcm', 'ldexp', 'left_shift', 'less', 'less_equal', 'lexsort', 'lib', 'linalg', 'linspace', 'little_endian', 'load', 'loads', 'loadtxt', 'log', 'log10', 'log1p', 'log2', 'logaddexp', 'logaddexp2', 'logical_and', 'logical_not', 'logical_or', 'logical_xor', 'logspace', 'long', 'longcomplex', 'longdouble', 'longfloat', 'longlong', 'lookfor', 'ma', 'mafromtxt', 'mask_indices', 'mat', 'math', 'matmul', 'matrix', 'matrixlib', 'max', 'maximum', 'maximum_sctype', 'may_share_memory', 'mean', 'median', 'memmap', 'meshgrid', 'mgrid', 'min', 'min_scalar_type', 'minimum', 'mintypecode', 'mirr', 'mkl', 'mod', 'modf', 'moveaxis', 'msort', 'multiply', 'nan', 'nan_to_num', 'nanargmax', 'nanargmin', 'nancumprod', 'nancumsum', 'nanmax', 'nanmean', 'nanmedian', 'nanmin', 'nanpercentile', 'nanprod', 'nanquantile', 'nanstd', 'nansum', 'nanvar', 'nbytes', 'ndarray', 'ndenumerate', 'ndfromtxt', 'ndim', 'ndindex', 'nditer', 'negative', 'nested_iters', 'newaxis', 'nextafter', 'nonzero', 'not_equal', 'nper', 'npv', 'numarray', 'number', 'obj2sctype', 'object', 'object0', 'object_', 'ogrid', 'oldnumeric', 'ones', 'ones_like', 'os', 'outer', 'packbits', 'pad', 'partition', 'percentile', 'pi', 'piecewise', 'place', 'pmt', 'poly', 'poly1d', 'polyadd', 'polyder', 'polydiv', 'polyfit', 'polyint', 'polymul', 'polynomial', 'polysub', 'polyval', 'positive', 'power', 'ppmt', 'print_function', 'printoptions', 'prod', 'product', 'promote_types', 'ptp', 'put', 'put_along_axis', 'putmask', 'pv', 'quantile', 'r_', 'rad2deg', 'radians', 'random', 'rank', 'rate', 'ravel', 'ravel_multi_index', 'real', 'real_if_close', 'rec', 'recarray', 'recfromcsv', 'recfromtxt', 'reciprocal', 'record', 'remainder', 'repeat', 'require', 'reshape', 'resize', 'result_type', 'right_shift', 'rint', 'roll', 'rollaxis', 'roots', 'rot90', 'round', 'round_', 'row_stack', 's_', 'safe_eval', 'save', 'savetxt', 'savez', 'savez_compressed', 'sctype2char', 'sctypeDict', 'sctypeNA', 'sctypes', 'searchsorted', 'select', 'set_numeric_ops', 'set_printoptions', 'set_string_function', 'setbufsize', 'setdiff1d', 'seterr', 'seterrcall', 'seterrobj', 'setxor1d', 'shape', 'shares_memory', 'short', 'show_config', 'sign', 'signbit', 'signedinteger', 'sin', 'sinc', 'single', 'singlecomplex', 'sinh', 'size', 'sometrue', 'sort', 'sort_complex', 'source', 'spacing', 'split', 'sqrt', 'square', 'squeeze', 'stack', 'std', 'str', 'str0', 'str_', 'string_', 'subtract', 'sum', 'swapaxes', 'sys', 'take', 'take_along_axis', 'tan', 'tanh', 'tensordot', 'test', 'testing', 'tile', 'timedelta64', 'trace', 'tracemalloc_domain', 'transpose', 'trapz', 'tri', 'tril', 'tril_indices', 'tril_indices_from', 'trim_zeros', 'triu', 'triu_indices', 'triu_indices_from', 'true_divide', 'trunc', 'typeDict', 'typeNA', 'typecodes', 'typename', 'ubyte', 'ufunc', 'uint', 'uint0', 'uint16', 'uint32', 'uint64', 'uint8', 'uintc', 'uintp', 'ulonglong', 'unicode', 'unicode_', 'union1d', 'unique', 'unpackbits', 'unravel_index', 'unsignedinteger', 'unwrap', 'ushort', 'vander', 'var', 'vdot', 'vectorize', 'version', 'void', 'void0', 'vsplit', 'vstack', 'warnings', 'where', 'who', 'zeros', 'zeros_like']\n"
     ]
    }
   ],
   "source": [
    "# Checking the available methods\n",
    "print(dir(np))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3010299956639812\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(np.log10(2))\n",
    "print(np.not_equal(10, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating a list in python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "[1, 2, 3, 4, 5]\n",
      "[[0, 1, 2], [3, 4, 5], [6, 7, 8]]\n"
     ]
    }
   ],
   "source": [
    "# Creating python List\n",
    "\n",
    "python_list = [1,2,3,4,5]\n",
    "# Checking data types\n",
    "print(type (python_list))\n",
    "print(python_list)\n",
    "two_dimensional_list = [[0,1,2], [3,4,5], [6,7,8]]\n",
    "print(two_dimensional_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating numpy array using numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "[1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "# Creating Numpy(Numerical Python) array from python list\n",
    "numpy_array_from_list = np.array(python_list)\n",
    "print(type (numpy_array_from_list))\n",
    "print(numpy_array_from_list)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numy_array_from_list2 = np.array(python_list)\n",
    "numy_array_from_list2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3., 4., 5.])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numy_array_from_list2 = np.array(python_list, dtype=float)\n",
    "numy_array_from_list2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True,  True, False, False])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy_bool_array = np.array([0, 1, -1, 0, 0], dtype=bool)\n",
    "numpy_bool_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "numpy_two_dimensional_list = np.array(two_dimensional_list)\n",
    "print(type (numpy_two_dimensional_list))\n",
    "print(numpy_two_dimensional_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy_array_from_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [6, 7, 8]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy_two_dimensional_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Converting numpy array to list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "one dimensional array: [1, 2, 3, 4, 5]\n",
      "two dimensional array:  [[0, 1, 2], [3, 4, 5], [6, 7, 8]]\n"
     ]
    }
   ],
   "source": [
    "# We can always convert an array back to a python list using tolist().\n",
    "np_to_list = numpy_array_from_list.tolist()\n",
    "print(type (np_to_list))\n",
    "print('one dimensional array:', np_to_list)\n",
    "print('two dimensional array: ', numpy_two_dimensional_list.tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [6, 7, 8]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy_two_dimensional_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating numpy array from tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "python_tuple:  (1, 2, 3, 4, 5)\n",
      "<class 'numpy.ndarray'>\n",
      "numpy_array_from_tuple:  [1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "# Numpy array from tuple\n",
    "\n",
    "# Creating tuple in Python\n",
    "\n",
    "python_tuple = (1,2,3,4,5)\n",
    "print(type (python_tuple))\n",
    "print('python_tuple: ', python_tuple)\n",
    "\n",
    "numpy_array_from_tuple = np.array(python_tuple)\n",
    "print(type (numpy_array_from_tuple))\n",
    "print('numpy_array_from_tuple: ', numpy_array_from_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy_array_from_tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Shape of numpy array\n",
    "The shape method provide the shape of the array as a tuple. The first is the row and the second is the column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "shape of nums:  (5,)\n",
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n",
      "shape of numpy_two_dimensional_list:  (3, 3)\n",
      "(3, 4)\n"
     ]
    }
   ],
   "source": [
    "nums = np.array([1, 2, 3, 4, 5])\n",
    "print(nums)\n",
    "print('shape of nums: ', nums.shape)\n",
    "print(numpy_two_dimensional_list)\n",
    "print('shape of numpy_two_dimensional_list: ', numpy_two_dimensional_list.shape)\n",
    "three_by_four_array = np.array([[0, 1, 2, 3],\n",
    "       [4,5,6,7],\n",
    "       [8,9,10, 11]])\n",
    "print(three_by_four_array.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data type of numpy array\n",
    "\n",
    "Type of data types: str, int, float, complex, bool, list, None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-3 -2 -1  0  1  2  3]\n",
      "int64\n",
      "[-3. -2. -1.  0.  1.  2.  3.]\n",
      "float64\n"
     ]
    }
   ],
   "source": [
    "int_lists = [-3, -2, -1, 0, 1, 2,3]\n",
    "int_array = np.array(int_lists)\n",
    "float_array = np.array(int_lists, dtype=float)\n",
    "\n",
    "print(int_array)\n",
    "print(int_array.dtype)\n",
    "print(float_array)\n",
    "print(float_array.dtype)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Size of a numpy array\n",
    "Instead of len size is used to get the length of items in a numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy_array_from_list.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy_two_dimensional_list.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mathematical Operation\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original array:  [1 2 3 4 5]\n",
      "[11 12 13 14 15]\n",
      "[-9 -8 -7 -6 -5]\n",
      "[10 20 30 40 50]\n"
     ]
    }
   ],
   "source": [
    "# Mathematical Operation\n",
    "\n",
    "# Addition\n",
    "print('original array: ', numpy_array_from_list)\n",
    "ten_plus_original = numpy_array_from_list  + 10\n",
    "print(ten_plus_original)\n",
    "ten_minus_original = numpy_array_from_list  - 10\n",
    "print(ten_minus_original)\n",
    "# Multiplication\n",
    "ten_times_original = numpy_array_from_list * 10\n",
    "print(ten_times_original)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int64\n",
      "float64\n",
      "float64\n"
     ]
    }
   ],
   "source": [
    "# Float numbers\n",
    "\n",
    "numpy_int_list = np.array([1,2,3,4])\n",
    "numpy_float_list = np.array([1.1, 2.0,3.2])\n",
    "numpy_float_list2 = np.array([1.1,2.0,3.2])\n",
    "\n",
    "print(numpy_int_list.dtype)\n",
    "print(numpy_float_list2.dtype)\n",
    "print(numpy_float_list.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Converting type from float to int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Converting type from float to int\n",
    "numpy_float_list.astype('int')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['1', '2', '3'], dtype='<U21')"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Converting type from int to str\n",
    "numpy_float_list.astype('int').astype('str')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dimensional Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "Shape:  (3, 3)\n",
      "Size: 9\n",
      "Data type: int64\n"
     ]
    }
   ],
   "source": [
    "# 2 Dimension Array\n",
    "two_dimension_array = np.array([(1,2,3),(4,5,6), (7,8,9)])\n",
    "print(type (two_dimension_array))\n",
    "print(two_dimension_array)\n",
    "print('Shape: ', two_dimension_array.shape)\n",
    "print('Size:', two_dimension_array.size)\n",
    "print('Data type:', two_dimension_array.dtype)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dimension_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to extract specific items from an array?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First row: [1 2 3]\n",
      "Second row: [4 5 6]\n",
      "Third row:  [7 8 9]\n"
     ]
    }
   ],
   "source": [
    "first_row = two_dimension_array[0]\n",
    "second_row = two_dimension_array[1]\n",
    "third_row = two_dimension_array[2]\n",
    "print('First row:', first_row)\n",
    "print('Second row:', second_row)\n",
    "print('Third row: ', third_row)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First column: [1 4 7]\n",
      "Second column: [2 5 8]\n",
      "Third column:  [3 6 9]\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "first_column= two_dimension_array[:,0]\n",
    "second_column = two_dimension_array[:,1]\n",
    "third_column = two_dimension_array[:,2]\n",
    "print('First column:', first_column)\n",
    "print('Second column:', second_column)\n",
    "print('Third column: ', third_column)\n",
    "print(two_dimension_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing in numpy is similar to list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [4, 5]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_two_rows_and_columns = two_dimension_array[0:2, 0:2]\n",
    "first_two_rows_and_columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to reverse the rows and the whole array?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dimension_array[::]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reverse only the row positions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[7, 8, 9],\n",
       "       [4, 5, 6],\n",
       "       [1, 2, 3]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dimension_array[::-1,]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reverse the row and column positions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[9, 8, 7],\n",
       "       [6, 5, 4],\n",
       "       [3, 2, 1]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_dimension_array[::-1,::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to represent missing values and infinite?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "[[ 1  2  3]\n",
      " [ 4 55 44]\n",
      " [ 7  8  9]]\n"
     ]
    }
   ],
   "source": [
    "print(two_dimension_array)\n",
    "two_dimension_array[1,1] = 55\n",
    "two_dimension_array[1,2] =44\n",
    "print(two_dimension_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0],\n",
       "       [0, 0, 0],\n",
       "       [0, 0, 0]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy Zeroes\n",
    "# numpy.zeros(shape, dtype=float, order='C')\n",
    "numpy_zeroes = np.zeros((3,3),dtype=int,order='C')\n",
    "numpy_zeroes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1 1]\n",
      " [1 1 1]\n",
      " [1 1 1]]\n"
     ]
    }
   ],
   "source": [
    "# Numpy Zeroes\n",
    "numpy_ones = np.ones((3,3),dtype=int,order='C')\n",
    "print(numpy_ones)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "twoes = numpy_ones * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "# Reshape\n",
    "# numpy.reshape(), numpy.flatten()\n",
    "first_shape  = np.array([(1,2,3), (4,5,6)])\n",
    "print(first_shape)\n",
    "reshaped = first_shape.reshape(3,2)\n",
    "print(reshaped)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flattened = reshaped.flatten()\n",
    "flattened"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 7 9]\n",
      "Horizontal Append: [1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "## Horitzontal Stack\n",
    "np_list_one = np.array([1,2,3])\n",
    "np_list_two = np.array([4,5,6])\n",
    "\n",
    "print(np_list_one + np_list_two)\n",
    "\n",
    "print('Horizontal Append:', np.hstack((np_list_one, np_list_two)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vertical Append: [[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "## Vertical Stack\n",
    "print('Vertical Append:', np.vstack((np_list_one, np_list_two)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Generating Random Numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6661632875670657"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Generate a random float  number\n",
    "random_float = np.random.random()\n",
    "random_float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.12945387, 0.1859908 , 0.47805876, 0.51996342, 0.52458233])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Generate a random float  number\n",
    "random_floats = np.random.random(5)\n",
    "random_floats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Generating a random integers between 0 and 10\n",
    "random_int = np.random.randint(0, 11)\n",
    "random_int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 8, 8, 9])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Generating a random integers between 2 and 11, and creating a one row array\n",
    "random_int = np.random.randint(2,10, size=4)\n",
    "random_int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[8, 9, 5],\n",
       "       [9, 8, 3],\n",
       "       [2, 3, 8]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Generating a random integers between 0 and 10\n",
    "random_int = np.random.randint(2,10, size=(3,3))\n",
    "random_int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 76.67233671,  87.8686846 ,  64.80771996,  79.44136527,\n",
       "        68.83066184, 102.85967631,  74.40838573,  58.56053793,\n",
       "        93.76814784,  82.16082568,  86.80548555,  77.95291907,\n",
       "        97.71514434,  95.94083876,  82.53018033,  73.74619803,\n",
       "        67.07970869, 102.20984782,  81.67766599,  73.82096132,\n",
       "        90.17632538, 102.87342877,  84.19855251,  81.11888938,\n",
       "        63.42782472,  75.3734846 ,  79.04423914,  56.52607352,\n",
       "        58.30505483,  54.69555571,  63.25792739,  88.75239018,\n",
       "        85.44533248,  59.76883843,  39.72683784,  78.1029094 ,\n",
       "        54.19952262,  82.383277  ,  87.01010766,  73.09642208,\n",
       "        81.99276776,  82.58990091,  72.71303439, 101.73499367,\n",
       "        73.65596295,  81.89611334,  96.14703307,  74.9629613 ,\n",
       "        84.79491744,  90.77830881,  70.69085365,  69.27799996,\n",
       "        74.07836137,  56.79410721,  76.08072393,  83.28246182,\n",
       "        83.66382654,  80.79644627,  83.39674788,  73.68044176,\n",
       "        59.74405724,  47.50763054,  50.99870066,  85.53776901,\n",
       "        80.61131428,  62.66726385,  69.8289171 ,  58.2394869 ,\n",
       "        86.5158869 ,  86.92976422,  65.12965299, 101.9918336 ,\n",
       "        73.3855881 ,  99.29788439,  82.48238578,  83.14592314,\n",
       "       109.13987986,  87.18461073,  73.18647475,  76.04712709,\n",
       "        67.2936962 ,  56.39363409,  81.35106332,  84.5083442 ,\n",
       "        64.45556043,  91.48890982,  82.97061603,  88.02694597,\n",
       "        79.98966974,  87.1672428 ,  98.96048765,  79.90801913,\n",
       "        66.33509656,  84.04023607,  88.09079879,  77.35006201,\n",
       "       103.55727658,  64.13437043,  68.05358071,  90.89443625,\n",
       "        82.79038989,  62.89514185,  74.97098809,  66.19397795,\n",
       "        92.70537742,  71.0629109 ,  96.37710058, 111.0582448 ,\n",
       "        82.49413524,  86.81684626,  51.59797622,  82.4090514 ,\n",
       "        67.44794517,  81.27167783,  56.5523663 ,  70.31869978,\n",
       "        73.27622806,  70.45432913,  69.65909073,  65.26697689,\n",
       "        92.09133852,  77.6409777 ,  75.12755482,  86.92392364,\n",
       "        52.345763  ,  61.21302273,  76.91865347, 101.50717646,\n",
       "        65.45696696,  79.72489732,  76.1272494 ,  95.31233116,\n",
       "       115.96549733,  75.92209483,  79.08231261,  97.77244182,\n",
       "        74.18461463,  66.86589353,  70.58006434,  37.59185572,\n",
       "       103.64455596,  48.23404954,  47.68141346,  69.76670989,\n",
       "       105.52887085,  67.35640534,  59.53778107,  79.01221476,\n",
       "        63.25760905,  53.41243319,  67.56688095,  89.44295326,\n",
       "        73.0249909 , 110.62094367,  75.30776079,  83.06746009,\n",
       "        72.00044242,  95.55925297,  87.41229729,  75.83119383,\n",
       "        81.76799949,  66.66909113, 111.87301683,  55.64386831,\n",
       "        88.2057447 ,  86.98310199,  90.64320901,  51.16660292,\n",
       "        86.44260395, 101.81543578,  54.33572759,  86.59505355,\n",
       "        74.96338672,  88.58073882,  99.97520135, 115.62885994,\n",
       "        48.33081456,  87.46330109,  92.57228694, 105.5973409 ,\n",
       "        74.69521182,  85.18418419,  71.00401484,  94.4873179 ,\n",
       "        89.58091544,  78.19894226,  78.62597505,  97.70529476,\n",
       "        48.9448779 ,  54.77461514,  80.84647783,  56.72044906,\n",
       "        53.17830126,  69.47376476,  62.70835212,  73.50984826,\n",
       "        79.95708327,  60.30922811,  68.71736216,  92.40372794,\n",
       "        86.23245168,  71.58967187,  58.57427101,  91.13298606,\n",
       "        54.02876851,  91.61300175,  73.85802225,  74.1262673 ,\n",
       "       113.37398924,  83.62799161,  69.67276347,  90.92422022,\n",
       "        93.80366456,  75.49340444,  69.68268106,  65.21188249,\n",
       "        73.08843699,  76.9702737 ,  86.63909332,  63.38692368,\n",
       "        59.0107169 ,  64.58012401,  67.77071814,  82.81680919,\n",
       "        47.00115734,  77.89249231,  94.57639045,  82.62969276,\n",
       "        89.2754606 ,  75.03679732, 105.40459045,  82.31470981,\n",
       "        91.73027956,  82.57265691,  73.93925755,  79.39961404,\n",
       "        78.42971467,  81.85491373,  98.50921957,  89.41696616,\n",
       "        64.5228743 ,  86.34810062,  85.53403969,  65.44710598,\n",
       "        97.61823581,  73.36500749,  78.7969976 ,  82.64530182,\n",
       "       102.5212311 ,  60.24103391,  88.97487767,  67.74463234,\n",
       "        87.06975383,  90.35731726, 113.93417792,  94.43622715,\n",
       "        75.68177623,  79.23496178,  63.19462299,  67.36853029,\n",
       "        39.35791739,  74.51434441,  72.60509108,  80.38587487,\n",
       "        68.68165911,  67.91476795,  73.7642702 ,  97.97756047,\n",
       "        99.15996313,  89.43595584,  53.27369357,  75.35961475,\n",
       "        93.21230424,  75.6875106 ,  75.20803627,  86.68011244,\n",
       "        73.46234329,  46.2650612 ,  85.99510379,  89.78716287,\n",
       "        86.54377973,  89.4421289 ,  66.35904948,  73.69434082,\n",
       "        72.16037244, 100.7404422 ,  76.81167206,  92.47498529,\n",
       "        51.99811087,  68.1875055 ,  97.21350945,  73.98272047,\n",
       "        79.9433559 ,  91.32704877,  70.36341543,  91.53287551,\n",
       "        64.0916329 ,  82.05669765,  59.91901105,  67.06455073,\n",
       "        90.82458082,  69.24155283,  86.00691215,  97.78612486,\n",
       "        57.53429118,  55.13961827,  65.92071751,  69.12679024,\n",
       "        80.24386507,  70.76561644,  52.38657486,  74.03314561,\n",
       "        55.08560907,  78.93565259,  72.12457096,  88.1878194 ,\n",
       "        69.26543786,  94.26645154,  57.22213699,  85.08262645,\n",
       "        75.15236761, 112.25159803,  60.69175095, 107.55714907,\n",
       "        97.40508175, 100.34600206,  71.64266763,  69.56735445,\n",
       "       105.37943464, 106.66581679,  69.88994757,  55.50599503,\n",
       "        96.85984215,  82.27633384,  71.99542571,  87.3033245 ,\n",
       "        53.9629657 ,  86.75436111,  93.71079875,  78.1735369 ,\n",
       "        59.12435725, 106.91289813,  90.55510253,  80.63892904,\n",
       "        49.52196748,  69.92138936,  82.59370828,  64.36717287,\n",
       "        83.46872542,  80.66546831,  73.272708  ,  85.55761189,\n",
       "        70.29998731,  85.27149783,  61.22698174, 112.1539227 ,\n",
       "        85.06829561, 105.62724187,  83.21087039,  91.47630885,\n",
       "        52.61117972,  96.39363125,  98.7615724 ,  82.3406285 ,\n",
       "        78.21209665,  81.68186011,  65.53179422,  81.636421  ,\n",
       "        48.28426725,  84.22834582,  72.65396863,  89.78723124,\n",
       "        62.69033062,  67.42236676,  61.70774152,  91.00289665,\n",
       "        65.8869877 ,  98.85053178,  90.95893416,  80.71673232,\n",
       "        69.1443606 ,  83.24469518,  53.61281569,  98.41838607,\n",
       "        95.89214815,  76.08288325, 105.95876474,  87.8123779 ,\n",
       "        98.83277115,  75.70467395,  64.52606003,  46.55761117,\n",
       "        61.35279897,  79.03475418,  70.26356208,  83.15010813,\n",
       "        71.35489747,  85.12422364,  79.6318843 ,  64.65930113,\n",
       "        50.39553485,  59.74637731,  97.17317934, 101.28981635,\n",
       "        55.51070593,  65.5724488 ,  56.9783323 ,  76.69243571,\n",
       "        80.22507493,  93.93824876,  74.27245434,  62.22895849,\n",
       "        61.71693803,  91.50874511, 102.93624517,  66.51614867,\n",
       "        73.66758854, 101.95706886,  80.17324289,  89.77788816,\n",
       "        79.41557833,  83.12691023,  78.39868201,  82.1245395 ,\n",
       "        75.39745528,  64.15220095,  66.19591545,  78.52233881,\n",
       "        69.45532022,  80.07279819,  92.05981037,  57.88406497,\n",
       "        78.39408713, 103.98322005,  71.85190829,  85.69820843,\n",
       "        78.01623836,  42.12347928,  82.10875153,  59.7121601 ,\n",
       "        75.6374047 ,  68.03654408,  75.31781043,  57.31129216,\n",
       "        82.6326405 ,  83.43080808,  81.52065719,  61.07178023,\n",
       "        65.89585315,  98.07305443,  57.04010365,  99.11343007,\n",
       "        82.03829385,  94.96220101,  63.10779942,  43.75533224,\n",
       "        60.96190311,  60.38889234,  86.01180327,  72.03287838,\n",
       "        88.56135551,  83.20459124,  85.33961473,  65.09373303,\n",
       "        72.95666996,  70.31639299,  82.84800507,  65.21994284,\n",
       "        83.71082556,  59.30552118,  57.24161946,  91.59640687,\n",
       "        81.07946716,  81.72062826, 104.82245391, 102.22642442,\n",
       "        85.5935274 ,  80.65595414,  85.21561212,  89.32052529,\n",
       "        70.80532767,  81.2402353 ,  73.3429679 ,  83.96484983,\n",
       "       102.14285344,  66.28045024,  69.08414849,  83.96027461,\n",
       "        99.882723  ,  92.56429669,  71.38334333,  91.29460474,\n",
       "        74.73563361,  82.61344943, 101.38451941,  96.22447959,\n",
       "        92.46992093,  73.64548057,  95.67625789,  97.30840065,\n",
       "        86.18687145,  39.79818989,  67.44627234,  78.81800827,\n",
       "        99.88127457,  97.08040669,  80.20672721,  61.6621477 ,\n",
       "        89.45069827,  69.2126993 , 105.30121908,  92.73651782,\n",
       "       104.02718862,  82.63560985, 117.14218447,  70.78186465,\n",
       "        69.38217047,  68.6752697 , 118.88261052,  94.16663109,\n",
       "        58.85480966,  84.43706331,  93.91832945,  59.99542403,\n",
       "        69.73006365,  87.14948387,  86.17056873,  72.04322939,\n",
       "        74.60316737,  65.4121187 ,  75.88172757,  73.0725911 ,\n",
       "        68.47916028,  88.94688011,  79.68974545,  66.22710966,\n",
       "        75.65901653,  65.17336078,  82.7854841 ,  68.54114688,\n",
       "        63.5422467 ,  85.27593096,  77.11949083,  85.1792345 ,\n",
       "        85.91031198,  94.40889745,  81.53460066,  78.13741406,\n",
       "        48.50311626,  74.00832439,  62.64749899,  26.42484343,\n",
       "        90.37956952,  47.85275007,  90.21932564,  71.54854049,\n",
       "        66.33008326,  61.45646105,  83.24146521,  77.85092006,\n",
       "        79.41867441,  82.35535991,  95.10042516, 104.55030347,\n",
       "        68.41918381,  62.24245143,  52.68448442,  61.93464607,\n",
       "        86.38263287,  81.40589031, 106.80202022,  76.64983598,\n",
       "        67.98843927,  81.30232608,  90.07378784,  66.33965558,\n",
       "        59.26391705,  90.22932022,  78.57688898,  60.99512356,\n",
       "        53.16782133,  76.80554089,  73.18463521,  75.74775613,\n",
       "        72.42763706,  84.15981253,  79.86702314, 107.59287088,\n",
       "        42.72244939,  94.10074796,  65.11731346,  92.44057941,\n",
       "        88.45199421,  49.7210141 ,  70.92988608,  84.87914436,\n",
       "       111.27471207,  71.10212581,  85.88122011,  85.39018312,\n",
       "        64.75059945,  80.19182056,  52.28697701,  63.63607001,\n",
       "        70.81836933,  92.12627834, 117.01393871,  84.55599041,\n",
       "        74.38388382,  72.05047965,  80.96294247,  76.95375672,\n",
       "        53.52743329,  68.26820071,  84.62245233,  83.76592911,\n",
       "        71.66491816,  62.84764731, 101.77473998,  83.7109928 ,\n",
       "        88.14356241,  70.56990958,  63.4114506 ,  97.03530829,\n",
       "        75.29544449,  86.46570106,  90.71226994,  59.58744577,\n",
       "        66.28889053,  81.81896037, 106.19049949,  76.79027375,\n",
       "       103.79328945,  68.83879663,  86.96337876, 109.07240618,\n",
       "        89.57507226,  71.02647491,  66.01655389,  63.71481491,\n",
       "        84.96881056,  81.47094049,  41.08479295, 102.81032149,\n",
       "        57.10553083,  74.69771968,  85.08750235,  77.86982387,\n",
       "        66.24827223,  77.61800937,  87.85279737,  97.44114529,\n",
       "        73.62465256,  84.87370213,  59.82819789,  83.51332999,\n",
       "        76.1564969 ,  92.80216207,  84.45078494,  98.12615727,\n",
       "        92.82159165,  77.68306951,  56.70024893,  96.13691428,\n",
       "        58.6947481 ,  62.43855793,  89.44203656,  88.39339383,\n",
       "        64.83174886,  80.20517572,  62.43358506,  90.35687599,\n",
       "        56.89696185, 101.4910522 ,  63.87426467,  64.76978812,\n",
       "        86.19666835,  64.7236682 ,  94.34248975,  75.09728512,\n",
       "        91.30899086,  96.6812488 ,  91.14172719,  82.51490688,\n",
       "        89.22153835,  82.87563357,  84.59497932,  41.99164693,\n",
       "        98.11955977,  79.61268968,  72.40763417,  73.97813269,\n",
       "        58.1632078 ,  62.83530224,  82.15621201,  71.28072756,\n",
       "       114.50107295,  98.83008872,  64.0437643 ,  99.65822453,\n",
       "        75.48720903,  63.32837291,  76.20823217,  86.84282223,\n",
       "        62.43082268,  73.15705444, 101.1511228 ,  76.82948915,\n",
       "        81.40991749,  69.48832828,  93.78545288,  84.11019295,\n",
       "        74.84590881,  80.41138779, 119.75165158,  94.30283763,\n",
       "        62.60960855,  80.05025988, 104.81265311,  83.38125656,\n",
       "        38.78328615,  62.41916009,  70.16735618,  51.44288365,\n",
       "        92.80525403,  84.92470846,  66.26844763,  74.71143692,\n",
       "        63.24518316, 101.03067104,  87.61812768,  81.78062237,\n",
       "        79.26854548,  82.45239206,  62.84682868,  75.85374972,\n",
       "        81.50671709,  91.61193178,  84.80540264,  76.83093669,\n",
       "        85.07574758,  78.12229555,  66.29072864,  95.26350438,\n",
       "        56.05352073,  75.24843365,  94.25579772,  80.29484646,\n",
       "        54.79358077,  80.00636677,  98.09007754,  65.05236219,\n",
       "        92.21169732,  93.78045193, 100.08258446,  50.34210852,\n",
       "        78.48684671,  92.46745685,  84.84801383,  80.80624528,\n",
       "       105.39277867,  95.79633397,  84.89636306, 113.4129892 ,\n",
       "        94.37919945,  33.04894125,  57.62445042,  74.70068129,\n",
       "        84.36545129,  58.65159412,  59.80499077,  72.37282525,\n",
       "        63.67362837,  60.15747326,  92.27103467,  67.58559178,\n",
       "        71.78018188,  78.50521982,  57.14143778,  87.75269721,\n",
       "        70.3938368 ,  85.84713936,  75.96861357,  77.60591163,\n",
       "        73.37361875,  94.88377692,  66.33736786,  67.73206898,\n",
       "        98.54323406,  97.7942897 ,  32.15593272,  92.2224777 ,\n",
       "        86.09657291,  79.07206812,  59.96670651,  67.31216781,\n",
       "        53.64584436,  55.49172965,  87.88340258,  93.21390739,\n",
       "        74.83629979,  74.97550995, 104.20264824,  85.90602294,\n",
       "        98.25959023,  82.32831776,  91.19296573,  68.66385157,\n",
       "        72.47319467,  66.32588349,  69.46771085,  84.80546774,\n",
       "        92.2537018 ,  91.61146021,  87.97125321,  77.40162354,\n",
       "        56.81359943, 100.63347184,  46.06026334,  64.3072636 ,\n",
       "        73.16833499,  66.58449357,  77.1759305 ,  80.95588782,\n",
       "        98.53819261,  93.8004291 ,  71.79955175,  71.8092341 ,\n",
       "        67.48364477,  76.92938082,  80.90556577,  76.3361884 ,\n",
       "        56.08189834,  69.72013329,  83.23890509,  87.63876162,\n",
       "        91.6671542 ,  65.9815465 ,  72.61972745,  98.36138944,\n",
       "        79.27809954,  83.22987584,  87.65365004,  89.72387738,\n",
       "        77.28925164,  96.80686114,  66.27593891,  58.22356418,\n",
       "        69.00110634,  98.69032179,  83.51534823,  54.84798906,\n",
       "        65.53428591,  64.14493646,  73.09656991,  80.90855247,\n",
       "        68.49764325,  66.70828679,  88.94583478,  68.08884137,\n",
       "       114.20054981,  48.43412772,  65.62243783,  76.5361132 ,\n",
       "        92.80262402,  73.745952  ,  77.88874597, 103.32373442,\n",
       "        82.78186246,  87.31269531,  82.7184332 ,  93.00860143,\n",
       "        86.81186734,  81.88725671,  85.57497866,  83.06657941,\n",
       "        73.92135462,  64.67840907,  54.1324434 ,  44.56198425,\n",
       "       103.74716492,  73.00720986,  79.70037455, 117.226086  ,\n",
       "        90.95959027,  82.93746876,  68.01202978,  51.38653362,\n",
       "        49.21376817,  82.98155396,  63.73945045,  71.87810968,\n",
       "        67.47155016,  50.17812178,  68.00005018,  74.54213222,\n",
       "        86.46204427,  81.88129502, 102.2539116 , 109.56599738,\n",
       "       101.67600164,  59.82763125,  66.7090957 ,  48.75955951,\n",
       "        84.40734607,  86.4125707 ,  31.21236081,  76.260938  ,\n",
       "        94.59278233, 112.3969095 ,  82.55898885,  66.22114921,\n",
       "        80.83856717,  85.08680709,  68.69636286,  69.71161312,\n",
       "        76.3196622 ,  78.68149223,  88.42004846,  78.94426232,\n",
       "        54.8348913 ,  82.21921133,  71.59374818,  82.0954091 ,\n",
       "        62.69406376,  79.16889409,  67.81528319,  95.83872873,\n",
       "        74.96783523,  81.70211669,  97.29360667,  51.07465606,\n",
       "        70.03123751,  94.59751783,  68.4839708 ,  51.8779431 ,\n",
       "        43.06271614,  53.56724106,  38.99403909,  92.53214605,\n",
       "       100.08867662,  74.91608135,  76.43190909,  77.23653514,\n",
       "       101.68713224,  74.48287587,  80.29475109,  86.49937422,\n",
       "        74.18560655,  90.32342146,  67.54203627,  61.65836826,\n",
       "        65.90214024,  90.18667155,  84.24811988,  87.31264766,\n",
       "        65.51077902,  73.6819876 ,  85.97917178,  84.60220551,\n",
       "        83.61993451,  81.97165845,  77.12380967,  85.92629768,\n",
       "        68.07735309,  97.04263534, 107.17028674,  56.66687639,\n",
       "        63.0328498 ,  95.71169257,  66.41415792,  73.01941362,\n",
       "        77.43739944,  80.91838286,  76.94361736,  92.45966561,\n",
       "        64.28909701,  90.86504202,  64.31354427,  68.00874105,\n",
       "        74.90902052,  46.84873109,  96.71448387,  92.88217861,\n",
       "        58.61271069,  74.34878286,  76.81571832, 100.83234903,\n",
       "        87.04080477,  76.17316306,  76.60724189,  57.03191229,\n",
       "       102.49683378,  84.94708014,  97.89869778,  51.74458192,\n",
       "        71.56589366,  71.92667719,  66.78215404,  90.44885288])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Generate random numbers\n",
    "# np.random.normal(mu, sigma, size)\n",
    "normal_array = np.random.normal(79, 15, 1000)\n",
    "normal_array\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy and Statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 1.,  0.,  1.,  2.,  0.,  1.,  3.,  3.,  4.,  2.,  4., 10.,  7.,\n",
       "        12., 15., 13., 20., 26., 16., 32., 36., 42., 38., 37., 35., 54.,\n",
       "        50., 40., 40., 55., 56., 49., 45., 29., 37., 26., 26., 23., 28.,\n",
       "        12., 22., 10., 11.,  5.,  3.,  6.,  4.,  4.,  3.,  2.]),\n",
       " array([ 26.42484343,  28.2913796 ,  30.15791576,  32.02445192,\n",
       "         33.89098809,  35.75752425,  37.62406041,  39.49059657,\n",
       "         41.35713274,  43.2236689 ,  45.09020506,  46.95674123,\n",
       "         48.82327739,  50.68981355,  52.55634972,  54.42288588,\n",
       "         56.28942204,  58.1559582 ,  60.02249437,  61.88903053,\n",
       "         63.75556669,  65.62210286,  67.48863902,  69.35517518,\n",
       "         71.22171134,  73.08824751,  74.95478367,  76.82131983,\n",
       "         78.687856  ,  80.55439216,  82.42092832,  84.28746449,\n",
       "         86.15400065,  88.02053681,  89.88707297,  91.75360914,\n",
       "         93.6201453 ,  95.48668146,  97.35321763,  99.21975379,\n",
       "        101.08628995, 102.95282611, 104.81936228, 106.68589844,\n",
       "        108.5524346 , 110.41897077, 112.28550693, 114.15204309,\n",
       "        116.01857926, 117.88511542, 119.75165158]),\n",
       " <a list of 50 Patch objects>)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set()\n",
    "plt.hist(normal_array, color=\"grey\", bins=50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# numpy.asarray()\n",
    "# Asarray\n",
    "# The asarray()function is used when you want to convert an input to an array. \n",
    "# The input could be a lists, tuple, ndarray, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "four_by_four_matrix = np.matrix(np.ones((4,4), dtype=float))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "four_by_four_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1.],\n",
       "        [2., 2., 2., 2.],\n",
       "        [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.asarray(four_by_four_matrix)[2] = 2\n",
    "four_by_four_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "# numpy.arange() in Python with Example\n",
    "# Whay is Arrange?\n",
    "# Sometimes, you want to create values that are evenly spaced within a defined interval. \n",
    "# For instance, you want to create values from 1 to 10; you can use numpy.arange() function\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 11, 2)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# creating list using range(starting, stop, step)\n",
    "lst = range(0, 11, 2)\n",
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for l in lst:\n",
    "    print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "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": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Similar to range arange numpy.arange(start, stop, step)\n",
    "whole_numbers = np.arange(0, 20, 1)\n",
    "whole_numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "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])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "natural_numbers = np.arange(1, 20, 1)\n",
    "natural_numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  3,  5,  7,  9, 11, 13, 15, 17, 19])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "odd_numbers = np.arange(1, 20, 2)\n",
    "odd_numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  4,  6,  8, 10, 12, 14, 16, 18])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "even_numbers = np.arange(2, 20, 2)\n",
    "even_numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.        , 1.44444444, 1.88888889, 2.33333333, 2.77777778,\n",
       "       3.22222222, 3.66666667, 4.11111111, 4.55555556, 5.        ])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# numpy.linspace()\n",
    "# numpy.logspace() in Python with Example\n",
    "# For instance, it can be used to create 10 values from 1 to 5 evenly spaced.\n",
    "np.linspace(1.0, 5.0, num=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1. , 1.8, 2.6, 3.4, 4.2])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# not to include the last value in the interval\n",
    "np.linspace(1.0, 5.0, num=5, endpoint=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "# LogSpace\n",
    "# LogSpace returns even spaced numbers on a log scale. Logspace has the same parameters as np.linspace.\n",
    "\n",
    "# Syntax:\n",
    "\n",
    "# numpy.logspace(start, stop, num, endpoint)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  100.        ,   464.15888336,  2154.43469003, 10000.        ])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.logspace(2, 4.0, num=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to check the size of an array\n",
    "x = np.array([1,2,3], dtype=np.complex128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.+0.j, 2.+0.j, 3.+0.j])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.itemsize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# indexing and Slicing NumPy Arrays in Python \n",
    "\n",
    "np_list = np.array([(1,2,3), (4,5,6)])\n",
    "np_list\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First row:  [1 2 3]\n",
      "Second row:  [4 5 6]\n"
     ]
    }
   ],
   "source": [
    "print('First row: ', np_list[0])\n",
    "print('Second row: ', np_list[1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First column:  [1 4]\n",
      "Second column:  [2 5]\n",
      "Third column:  [3 6]\n"
     ]
    }
   ],
   "source": [
    "print('First column: ', np_list[:,0])\n",
    "print('Second column: ', np_list[:,1])\n",
    "print('Third column: ', np_list[:,2])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## NumPy Statistical Functions with Example\n",
    "NumPy has quite a few useful statistical functions for finding minimum, maximum, percentile standard deviation and variance, etc from the given elements in the array.\n",
    "The functions are explained as follows −\n",
    "Statistical function\n",
    "Numpy is equipped with the robust statistical function as listed below\n",
    "\n",
    "- Numpy Functions\n",
    "    - Min\tnp.min()\n",
    "    - Max\tnp.max()\n",
    "    - Mean\tnp.mean()\n",
    "    - Median\tnp.median()\n",
    "    - Standard deviation\tnp.std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "min:  1\n",
      "max:  55\n",
      "mean:  14.777777777777779\n",
      "sd:  18.913709183069525\n"
     ]
    }
   ],
   "source": [
    "np_normal_dis = np.random.normal(5, 0.5, 100)\n",
    "np_normal_dis\n",
    "## min, max, mean, median, sd\n",
    "print('min: ', two_dimension_array.min())\n",
    "print('max: ', two_dimension_array.max())\n",
    "print('mean: ',two_dimension_array.mean())\n",
    "# print('median: ', two_dimension_array.median())\n",
    "print('sd: ', two_dimension_array.std())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4 55 44]\n",
      " [ 7  8  9]]\n",
      "Column with minimum:  [1 2 3]\n",
      "Column with maximum:  [ 7 55 44]\n",
      "=== Row ==\n",
      "Row with minimum:  [1 4 7]\n",
      "Row with maximum:  [ 3 55  9]\n"
     ]
    }
   ],
   "source": [
    "print(two_dimension_array)\n",
    "print('Column with minimum: ', np.amin(two_dimension_array,axis=0))\n",
    "print('Column with maximum: ', np.amax(two_dimension_array,axis=0))\n",
    "print('=== Row ==')\n",
    "print('Row with minimum: ', np.amin(two_dimension_array,axis=1))\n",
    "print('Row with maximum: ', np.amax(two_dimension_array,axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to create repeating sequences?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tile:    [1 2 3 1 2 3]\n",
      "Repeat:  [1 1 2 2 3 3]\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3] \n",
    "\n",
    "# Repeat whole of 'a' two times\n",
    "print('Tile:   ', np.tile(a, 2))\n",
    "\n",
    "# Repeat each element of 'a' two times\n",
    "print('Repeat: ', np.repeat(a, 2))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to generate random numbers?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.4763968133790438\n"
     ]
    }
   ],
   "source": [
    "# One random number between [0,1)\n",
    "one_random_num = np.random.random()\n",
    "one_random_in = np.random\n",
    "print(one_random_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.67018871 0.71699922 0.36490538]\n",
      " [0.78086531 0.5779336  0.81444353]]\n"
     ]
    }
   ],
   "source": [
    "# Random numbers between [0,1) of shape 2,3\n",
    "r = np.random.random(size=[2,3])\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['i' 'u' 'e' 'o' 'a' 'i' 'e' 'u' 'o' 'i']\n"
     ]
    }
   ],
   "source": [
    "print(np.random.choice(['a', 'e', 'i', 'o', 'u'], size=10))  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.66811333, 0.1139411 ],\n",
       "       [0.90955775, 0.14954203]])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## Random numbers between [0, 1] of shape 2, 2\n",
    "rand = np.random.rand(2,2)\n",
    "rand"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.84819546, -0.39626819],\n",
       "       [ 0.9172979 ,  0.03661474]])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rand2 = np.random.randn(2,2)\n",
    "rand2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 7, 0],\n",
       "       [0, 2, 7],\n",
       "       [5, 9, 4],\n",
       "       [6, 0, 8],\n",
       "       [4, 6, 2]])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Random integers between [0, 10) of shape 2,5\n",
    "rand_int = np.random.randint(0, 10, size=[5,3])\n",
    "rand_int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "min:  3.566493784430423\n",
      "max:  6.823091905048957\n",
      "mean:  5.034308251615374\n",
      "median:  5.0317142506545505\n",
      "mode:  ModeResult(mode=array([3.56649378]), count=array([1]))\n",
      "sd:  0.5050902240094916\n"
     ]
    }
   ],
   "source": [
    "from scipy import stats\n",
    "np_normal_dis = np.random.normal(5, 0.5, 1000)\n",
    "np_normal_dis\n",
    "## min, max, mean, median, sd\n",
    "print('min: ', np.min(np_normal_dis))\n",
    "print('max: ', np.max(np_normal_dis))\n",
    "print('mean: ', np.mean(np_normal_dis))\n",
    "print('median: ', np.median(np_normal_dis))\n",
    "print('mode: ', stats.mode(np_normal_dis))\n",
    "print('sd: ', np.std(np_normal_dis))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([  3.,   7.,  11.,  22.,  41.,  64.,  72., 109., 117., 122., 117.,\n",
       "         93.,  94.,  47.,  36.,  20.,  15.,   5.,   3.,   0.,   2.]),\n",
       " array([3.56649378, 3.72156989, 3.87664599, 4.03172209, 4.18679819,\n",
       "        4.34187429, 4.49695039, 4.65202649, 4.80710259, 4.96217869,\n",
       "        5.11725479, 5.2723309 , 5.427407  , 5.5824831 , 5.7375592 ,\n",
       "        5.8926353 , 6.0477114 , 6.2027875 , 6.3578636 , 6.5129397 ,\n",
       "        6.6680158 , 6.82309191]),\n",
       " <a list of 21 Patch objects>)"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(np_normal_dis, color=\"grey\", bins=21)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "# numpy.dot(): Dot Product in Python using Numpy\n",
    "# Dot Product\n",
    "# Numpy is powerful library for matrices computation. For instance, you can compute the dot product with np.dot\n",
    "\n",
    "# Syntax\n",
    "\n",
    "# numpy.dot(x, y, out=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## Linear algebra\n",
    "### Dot product: product of two arrays\n",
    "f = np.array([1,2])\n",
    "g = np.array([4,5])\n",
    "### 1*4+2*5\n",
    "np.dot(f, g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## Linear algebra\n",
    "### Dot product: product of two arrays\n",
    "f = np.array([1,2,3])\n",
    "g = np.array([4,5,3])\n",
    "### 1*4+2*5 + 3*6\n",
    "np.dot(f, g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NumPy Matrix Multiplication with np.matmul() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[19, 22],\n",
       "       [43, 50]])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### Matmul: matruc product of two arrays\n",
    "h = [[1,2],[3,4]] \n",
    "i = [[5,6],[7,8]] \n",
    "### 1*5+2*7 = 19\n",
    "np.matmul(h, i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Determinant 2*2 matrix\n",
    "### 5*8-7*6np.linalg.det(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.999999999999999"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.det(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "Z = np.zeros((8,8))\n",
    "Z[1::2,::2] = 1\n",
    "Z[::2,1::2] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 1., 0., 1., 0., 1., 0., 1.],\n",
       "       [1., 0., 1., 0., 1., 0., 1., 0.],\n",
       "       [0., 1., 0., 1., 0., 1., 0., 1.],\n",
       "       [1., 0., 1., 0., 1., 0., 1., 0.],\n",
       "       [0., 1., 0., 1., 0., 1., 0., 1.],\n",
       "       [1., 0., 1., 0., 1., 0., 1., 0.],\n",
       "       [0., 1., 0., 1., 0., 1., 0., 1.],\n",
       "       [1., 0., 1., 0., 1., 0., 1., 0.]])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_list = [ x + 2 for x in range(0, 11)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np_arr = np.array(range(0, 11))\n",
    "np_arr + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 7,  9, 11, 13, 15])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([1,2,3,4,5])\n",
    "y = x * 2 + 5\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEXCAYAAAC3c9OwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3dd3xV9f3H8VcS9sYQQVG2fNhb0Voq7oUDceKuoy5s62pr6692/zptRa2jrlZrawu4wIWKW1GGCevDkLBnWAkQSHLv749zYm/5heQm5I4k7+fjwYPcc885n8/33uR+7lmfkxGNRhEREdlXZqoTEBGR9KQCISIiFVKBEBGRCqlAiIhIhVQgRESkQioQIiJSoUapTkDqLjO7H/hG+LAfsBzYHT4+xt13V7hgmjCzDOBN4Hx335bqfPZlZj8HvgWsAaJAFrABuNHdl6YyN2kYVCCkxtz91vKfzSwfuNTdP09ZQtWXBZyY6iSq8Ky7f6f8gZl9F3gGODp1KUlDoQIhCWNm/YE/Ae0JPozvc/enzewk4F5gHXAEUAT8BrgV6A087+53hPP9FFgLWDjfVe7uZtY0XGZUuO5ZwLfdvdDMVgMfAIOBuwh2pX4PaArkAE+4+73Ak2Gq75vZqcBMYIy7zw3zXw2MCeNOB5YCh4cxewP/C7QAyoAfu/u0fcZ/E3Cyu48NHw8ApgHdwnGdA+wBNgNXuvuGOF7Wt4Afh+v7gGCLoi/wAPBc+Hr3BxoTbB3d5e5l4dbI/4tX0XSgACgB2rv7NjNrVP4YGAH8FigGmgNHAWcAd4cxdwK3u/uncYxF0pyOQUhCmFlj4F8EHxbDgdHAD8xsRDjLSOBn7j6EYLfUncDpBB9A3zGzg2Pm+4O7DwSeBZ4Op/8wXG64uw8m+HD7RUwKX7h7X2AqcDtwWZjHscA9ZtYeuDqcd5S7r61iSF2Be9zdCArC48B4dx8GjAUeNbPD9lnmWeB4M8sJH18NPBGu66Yw9xHA2wQftJUKP6i/CbwTM3mzu/dz94cIisPH4TiHAocA3zaz7hXF29/0qvIABgIXhO9dD+AnwKnuPjRc3xQzaxbHeiTNaQtCEqUvwYfH02ZWPq0pwQfXcmCpu+eG05cBG9y9BNhoZkXAQeFzs9z9o/DnvwD3m1lbgm/2rYDTwvU3IdjSKPc+gLtHzOxMYIyZXU5wrCSD4Jt/YTXGsxco/1Z8LMGH70sxY4sAA4DV5RPcfbuZvQhcamYPAJcQ7BpaCywAZpvZNOBVd4/90I91qZmNDn9uDHxOcFziv8YZOhMYZmblzzcn2DK4v6J4YcHZ3/TK5Lt7+ThPAToD78S8FlGgJzC/ivVImlOBkETJAgrCb5kAmFknYBvwdYIPrlgl+1lPaczP5Vu8ZeH6b3b3N8N1tyYoEuWKYqbPAf5NsNvpCeA8giKxr+g+02PXt9vdIzFjy3P3Y2PG1hnYWME6HyP4gF5OsFWzMpx/FMG39ROBiWb2krvfXcHy/3UMogJFMT83Asa6+5IwRnsg4u6l+4tX0XTgnnB95a9F7Ouwb8ws4HV3vzTmtTic4MC61HHaxSSJsgCImNnFAGbWleAb5eBqrmd4eCwDgm/O77p7EfA6MMHMGptZFsEH/88rWN4IthbucfdXCD4IGxF8sJURFIXG4bybCHZxER7/yPl/awt8BPQzs2PDeYcBi4GO+87o7h8AzQh2iT0WM38uMM/df0mwa+jIuF6Nyr0OfNfMMsJdPK8AN+wv3v6mu3sZsJXwtQDGVxLzLeB0M+sdju1sYG44ZqnjVCAkIdx9D3A2cKOZ5QKvAd+vwcHLdcCvzWwewcHQK8Pp9xLszplLUHhKCI5j7GsO8AawyMwWAqcBi4Be7h4FJgEfmFlfggPad5jZXOCicN0VjW0DcD5wn5l9ATxFcDxidUXzE+wa6wq8HC4/G5gCzDKzz4ErgDvieTGqcDPBgeQ84AtgNvD7/cWrIo8JBMdVZhHsLtpUUcBwN+GNwPPha/E/wNnuvqsWxiMplqF235Kuwm/xv4vdTSUiyaMtCBERqZC2IEREpELaghARkQqpQIiISIXq0nUQTQlOBVxHcHqiiIhULYvgws7P+P/XH1WqLhWII/nvq0ZFRCR+owguFo1bXSoQ6wC2bt1JJJL8A+vZ2a0oKCiqekbFrbOxNeaGEbuhxc3MzKB9+5YQfoZWR10qEGUAkUg0JQWiPLbi1u/YGnPDiN3Q4oaqvWteB6lFRKRCKhAiIlIhFQgREalQwo9BmFkbgu6XY9w938yeJGj3vDOc5SfuPiXReYiISPUktECY2UiCFse9YyaPAL7h7tU+oi4iIsmT6F1M1xG0IF4LYGYtgC7AE2aWa2Y/MTPt5hKReq8u9r1L6Iezu1/r7rEXt3UiuO/tNwluvTgKuCaROYiIpFIkGmXye19y+b2vsat4fzdOTE9J6eZqZvnAaHfP32f6WOAKdx8bx2q6Edy2UUSkTthVXMLvn53NzAXrOWVkV265YDAZGRXd7TYpugP51VkgqRfKmdlAoLe7TwonZbD/exFXqKCgKCUXm+TktGbTpurc415x61psjblhxE5W3A1bdnH/pFw2bNnNpSf35qJT+7B5c2qupM7OblWjZZN9JXUG8Ecze5vgxufXA08nOQcRkYSa92UBD784n8zMDO64eAh9urZP5ZZDjSW1QLh7rpn9CviQ4Ebxk9z9uWTmICKSKNFolNdnruJfM5bSuUMrbh03kA7tmqc6rRpLSoFw924xPz8EPJSMuCIiybK3pIynXlvEJ/M3MKLPwVxzRl+aNslKdVoHpC416xMRSUtbdhQzcXIeK9cXct43enDmMV3r5C6lfalAiIgcgCWrt/Hg5Dz2lkaYMG4QQ47okOqUao0KhIhIDb07dw3PvLGYDm2bcdf4QRzaoWWqU6pVKhAiItVUWhbhubeW8M7sNQzofhDfOqc/LZs1TnVatU4FQkSkGnbs2stDU+axeNU2ThvZhfOP60lmZt0/3lARFQgRkTit3FDIxEm57NhVwnVn9eOY/p1SnVJCqUCIiMRh5sINPDF1IS2bN+YHlw2jW6c2qU4p4VQgREQqEYlEmfL+l0z9eAW9DmvLzWMH0rZlk1SnlRQqECIi+7GruJRHX55P7rICjhtyKJee3JtGWQ3nDgUqECIiFVhXsJOJk/LYtG03l59qHD+0c6pTSjoVCBGRfeQuK+CRl+aTFTbbsy7tU51SSqhAiIiEotEor366kkkzlnH4wa24ZdxAOrStu832DpQKhIgIsKekjCenLWTmwo0c1fdgrj6jL00b1+1mewdKBUJEGryC7cVMnJzLqg1FjDuuB2ccXT+a7R0oFQgRadAWr9rGg1PyKC2LcOv5gxjcq/402ztQKhAi0mC9M2cNf39zMR3aNefWcQM5JLt+Nds7UAktEGbWBvgIGOPu+THTbwHOd/fRiYwvIlKR0rIIf39zMTPmrmVQz2yuP6sfLephs70DlbACYWYjgceA3vtM7wd8H1iaqNgiIvuztbCY3z43hyWrt3PG0V057xs96m2zvQOVyEsCrwNuBtaWTzCzpsAjwP8kMK6ISIVWrC/ktj++x4r1hXzr7P6cP7r+dmKtDRnRaDShAcwsHxjt7vlm9gcgD1gO3FvNXUzdwuVERKrt3dmruf+fc2jTqik/vPooeh3WLtUpJVt3IL86CyTtILWZnQx0cffbzGx0TddTUFBEJJLYolaRnJzWbNpUqLj1OLbGXD9jRyJRJr27jFc/XUnvw9pyz7XHUFK8N+njTtVrnZmZQXZ2qxotm8yzmC4B+pvZXKAV0MnM/unuFyUxBxFpQHYVl/DwS/OZ9+UWjh/amUtOOoJ2rZuyqXhvqlOrE5JWINz9m+U/h1sQ96o4iEiirCvYyf3/zmXz9mKuONUY3QCb7R0oXQchIvXO3KWbeezl+TTOyuTOS4bS+/AGd7yhViS8QLh7twqmzQBGJzq2iDQs0WiUqR+vYMp7X9KlY2smjBvIQW2apTqtOktbECJSL+zZW8YT0xby2aKNHN2vI1ee3qfBN9s7UCoQIlLnbd62m4mT81i9sYgLju/JaUd1UbO9WqACISJ1mq/cyoNT5lEWifKdCwczsEd2qlOqN1QgRKROikajvDNnDc9NX8LB7ZszYdwgOh3UItVp1SsqECJS55SURnj2Tee9L9YxuGc2153VnxbN9HFW2/SKikidsr1oDw9OmcfSNdsZ87WunDuqB5k63pAQKhAiUmcsX7eDBybnsbO4hBvO6c9RfTumOqV6TQVCROqEj+et56nXFtGmRRPuvmw4XTq2TnVK9Z4KhIiktUgkyr9nLOO1mSvp06UdN5w7gDYtmqQ6rQZBBUJE0tbO4hIefnE+85dv4cRhh3HRib1olJXI29hILBUIEUlLazbvZOKkXAq2F3PV6X34xuBDU51Sg6MCISJpZ86STTz68gKaNs7ie+OH0euwtqlOqUFSgRCRtBGNRnnlo3ymvL+cbp1ac8t5araXSioQIpIWiveW8vjUhczyTRzTvyNXntaHJmq2l1IqECKScpu27WbipFzWbN7JRSf04pQjD1ezvTSgAiEiKbUwfwt/fnE+kUiU7144mAHd1WwvXSS8QJhZG+AjYIy755vZjcAtQAYwFbjL3aOJzkNE0ks0GmX656v4x1tL6ZTdggnjBtKxvZrtpZOEFggzGwk8BvQOH3cHbgOGAMXAe8DJwBuJzENE0ktJaYSJz8/lzZkrGXpEB64d04/mTbVDI90k+oqT64CbgbUA7r4c6OfuO4F2QFtgW4JzEJE0sq1oD795bjZvzlzJWV/rxs3nDVRxSFMZ0Wji9+6YWT4w2t3zw8fXAb8DZgJnuvveOFbTDViemAxFJBkWr9zKL56cyc7iEr578TCO1cVvydQdyK/OAikp2+7+mJk9CTwJ3AvcHe+yBQVFRCLJP2SRk9OaTZsKFbcex9aYE+vDvHU8/ZrTrlXQbG9Y/0Pq/ZjTIW5mZgbZ2a1qtmwt51IpMzvczI4FcPdS4B/AoGTmICLJVRaJ8I+3lvD41IX06tyGe64cweEH1+wDS5Ir2VsQbYFnzWwIsB04H/ggyTmISJIU7S7h4RfnsSB/KycNP4wLT1CzvbokqQXC3eeZ2a8ITnstBd4Hfp/MHEQkOVZvKmLipFy2Fu7h6jP6MGqQjjfUNUkpEO7eLebnR4BHkhFXRFJjlm/iL68soFmToNlez85qtlcX6dwyEak1kWiUlz/M58UPltP9kDbcct5A2rdumuq0pIZUIESkVuzeEzTbm714E8cO6MQVpxmNG6nZXl2mAiEiB2xj2Gxv7eadXHziEZw84jA126sH4ioQZnY0cFDsNHeflpCMRKROmZ+/hYdfmAfAbRcNoX+3g6pYQuqKKguEmf0DGEXYLiMUBVQgRBqwaDTKm5+v5p9vL+HQ7JZMGDeQg9Vsr16JZwtiBNDD3fckOhkRqRtKSsv462vOh/PWM6x3Dtec2Vf9lOqheN7RReF8KhAiwtbCPTwwOY/l63Zwzte7c9ax3cjU8YZ6KZ4C8QiQa2YfASXlE939mwnLSkTS0rI123lgSh7Fe8q4eexAhltOqlOSBIqnQPwEeB1YluBcRCSNvZ+7lr+97rRv3ZTbLxrCYTnqp1TfxVMgytz9poRnIiJpqbQswvNvL2X6rNX069aeG84ZQKvmjVOdliRBPF2zZpnZmQnPRETSTtHuEu57/gumz1rNKUcezncvHKzi0IDEswVxMnC9me0F9hLcSzrq7m0SmpmIpNSqjUGzvW1Fe7nmzL4cO/CQVKckSRZPgTihgmk6ZUGkHvt80Ub+MnUBzZs24nuXDqXnoWq21xDFUyAedvfTYyeY2SfA0YlJSURSJRKN8uL7y3n5o3x6HtqGm8aq2V5Dtt8CYWb/BnoDPc0sN+apxuiaCJF6Z/eeUh57eQFzl27m6wMP4fJTjcaNdHOfhqyyLYg7gG7AY8CEmOmlwIJ4A5hZG4IbBI1x93wzux64laBdx+fAt9x9bzXzFpFatGHrLiZOymN9wS7Gn3QEJw5Xsz2ppEC4ez6Qb2bm7pHY58ysZTwrN7ORBAWmd/i4N3AnMBwoBJ4Cbgbuq0HuIlIL5i0v4OEX5pORAbdfNJi+arYnoXiOQZxlZj8FWhEcnM4i6OzaOo5lryMoAH8LH+8BbnL3HQBmlgd0qW7SInLgotEoU2Ys5clX5tO5Q0smjBtETrvmqU5L0kg8BeJ3wI+AG4BfA2OBHfGs3N2vBTCz8scrgBXhtBzgFuCqauYsIgdob0kZT7+2iI/nb2C4Bc32mjVRsz35b/H8Rux093+a2RCgGLgRmE+wq6hGzKwz8CrwuLvPqM6y2dmpu7w/JyeejSbFrcuxG8KYN2/bze+enc3SVdu49LQ+XHhibzIzU3O8oaG9z6n8/aqJeApEsZk1BZYCQ9x9hplFaxrQzPoQ9Ha6391/X93lCwqKiERqHL7GcnJas2lToeLW49gNYcxLVwfN9vaUlDHhvIGccmyPej/mhh43MzOjxl+s4ykQLwFTgSuBj81sFLC5JsHMrDXwBvBDd/9bVfOLSO1574ug2V52m2bcefEQOqvZnlShypOc3f2XwDfdfQ1wDvAecH4N410LdARuN7O54b+f1nBdIhKH0rIIz7zhPPXqIvp0bc+Prhyh4iBxieuolLuvDP+fA8ypbhB37xb+eB86pVUkaXbs2svDL8xj0cptnHZUF8aN7kFWpi5+k/jotAWRemrlhkImTspj+869XDemH8cM6JTqlKSOUYEQqYdmLtzAE9MW0rJZY35w2TC6H6Lmy1J9KhAi9UgkGmXKe18y9eMV9OrclpvHDqBtKzXbk5qpskCY2bnAH4H2BFdS634QImloV3Epj708ny+WFTBq0CFcdoqa7cmBiWcL4tfAbcBsggZ7IpJm1m/ZxcRJuWzcuptLT+7NCcM6q9meHLB4CsQ2d5+c8ExEpEZylxXwyEvzycrM4PaLhtCna/tUpyT1RDzbn5+a2elVzyYiyRSNRnn1kxX86V9f0KFtM/7nyhEqDlKr4tmCOAO4RfekFkkfe0rKeOrVRXy6YAMj+hzMNWf0pWmTrFSnJfVMPAXixIRnISJxK9hezAOT81i5oZBxx/XgjKO76niDJERltxw9wd3fJri5T0VWJCYlEdmfxau28dCUPPaWRphw/iCG9OqQ6pSkHqtsC+IS4G3++3aj5aKADlyLJNGMOWt49s3FdGjbjLvGD+LQDnHd2FGkxiq75eh14f/HJy8dEdlXaVmEv09fwow5axjQ4yBuOLs/LZo1TnVa0gDoSmqRNLZj514empLH4tXbOX1kF8Yd1zNlN/eRhkcFQiRNrVhfyMTJuRTuKuH6s/pxdH8125PkUoEQSUOfLtjAk9MW0rJ50GyvWyedVS7JF1eBMLPzgSHAL4Fz3P25hGYl0kBFIlEmv/cl0z5ZwRGHteWmsQNp27JJqtOSBiqeZn3fB04GDie42c+PzayXu/8sngBm1gb4CBjj7vnhtMbAa8DP3H1GzVIXqV92FZfwyEsLyPuygNFDDmX8yb1plKVme5I68fz2XUxwNfVOdy8AjgbGx7NyMxsJfAD0jplmwAzga9VNVqS+WrWhkJ/9dRYL8rdw+anGFaf1UXGQlIvnN7DE3feUP3D3bUBJnOu/DrgZWBsz7Rrgt8Cn8SYpUp99sXQzd9z/HruKS7jj4iEcP7RzqlMSAeI7BrHKzM4EombWFLiDOK+idvdrAYKNhq+m3RVO+061sxWpR6LRKNM+WcHkd7+ke+e23Hh2f7LbNkt1WiJfiadA3AL8DRgE7AQ+Ic5dTImQnd0qVaHJyWmtuPU8drLiFu8p5f7n5/L+3DWMGtKZWy8aQrMmqTmpUO9z/Y9bU/H8Rh7p7ieaWQsgy90LE51UZQoKiohEkn/fopyc1mzalPyhN7S4qYydrLibt+/mgUl5rNpYxPmje3L6yC40a9KoXo85nWI3tLiZmRk1/mIdT4H4JfCiu++qUQQR+Yqv3MqDU+ZRFony7QsGMainmu1J+oqnQOSZ2Q+B94Gi8onuPjthWYnUM9FolBlz1vD36UvIadecCeMGcki2mu1JeounQIwM/10bMy0K9Ig3iLt3q2Da6HiXF6nLSssiPPvmYt6du5ZBPbO5/qz+tGimJgaS/qr8LXX37slIRKQ+2r5zLw9OyWPp6u2ceUxXxo7qoWZ7UmfEcyX1bRVNd/c/1H46IvXH8nU7eGByHjt3l3DDOf05qm/HVKckUi3xbOcOjPm5CXAc8FZi0hGpHz6ev56nXl1EmxaN+cFlw+naqW6d3igC8e1iujr2sZkdCjyesIxE6rBIJMq/ZyzjtZkr6X14O246dwBt1GxP6qhqHylz97Vm1i0BuYjUaTuLS3jkxfnMW76F44d15pITj1A/JanTqnsMIgMYAWxMWEYiddDazTu5f1IuBduLueI0Y/QQ9VOSuq+6xyCiwErgzsSkI1L3zF2ymUdfnk+TRpnceclQeh/eLtUpidSKah2DMLMmQCd3X53QrETqgGg0yisfr+CF976kS6fWTDhvIAe1UbM9qT/i2cU0FjgBuBvIA9qa2b3u/qdEJyeSrvbsLePxaQv5fNFGju7XkatO70OTxlmpTkukVsWzi+kHBPdwGAd8DHwLeBtQgZAGadO23UyclMeazUVceHwvTj3qcDIydPGb1D/xnGKR4e55wEnAq+6+I87lROqdhSu28rOnP6dgRzHfuWAwp43souIg9VY8WxARM7sQOBW4w8zOACKJTUskvUSjUd6evYbnpi+h40HNmTBuEJ0OapHqtEQSKp4CcTtwL3C3u68PO7vemtCsRNJISWmEZ95w3s9dx+Ce2Vx/dn+aN1WzPan/4jmL6QOC3UvlZzFd4u4rE52YSDrYVrSHB6fksWzNDsZ8rSvnjupBpnYpSQOhs5hE9uOrZnvFJdx47gCO7HNwqlMSSap4Djb/AHiU/5zF1BW4PJFJiaTah3nr+NUzs8nMyODuy4arOEiDlPCzmMysjZnNK+/fZGYnmVmumS0xs5/XKGuRBCmLRPjHW0t4fOpCenVuwz1XjaBLR3VilYYpng/62LOY3qjOWUxmNhL4AOgdPm4OPAGcA/QFjjSz02uSuEhtK9y1lz8+/wVvfLaKE4cdxm0XDaFNC3VilYYrngJxO3A98EN3Xw9U5yym64CbgbXh46OAJe6+3N1LgWeAC6qXskjtW7OpiNv/+B6LVm7jqtP7cOkpvdWJVRq8jGg0GteMZtbO3bfVJIiZ5QOjgWOAM939snD6ScBd7n5KHKvpBiyvSXyRynyct477nptF0yaNuPvKo+jb/aBUpySSCN2B/OosEM9ZTAZMITh76ShgOjDW3RfVIMFMgo6w5TKo5kV3BQVFRCLxFbXalJPTmk2bChW3HsWORKO88mE+L3ywnG6dWvPj644hWlLaoF7vhvA+N/S4mZkZZGe3qtmyccwzEfg2sNHd14SPH61RNFgNHBLzuBP/2f0kkjTFe0v585R5vPDBco7p35HvXzqMDu2apzotkbQST4HIdvc3yx+4+0NAmxrG+5Rgo6SXmWUB44FXa7gukRrZuG03v/jbLGYv2cRFJ/Ti2jH91IlVpALx9AuImlkzwl1DZtYJqNFfk7sXm9lVwCSgGTAN+HdN1iVSEwvyt/DnF+YBcNuFQ+iv4w0i+xVPgfgz8DpwsJn9CrgE+HV1grh7t5if3wIGV2d5kQMVjUaZ/vlq/vn2Ujplt2DCuIF0bK9meyKViacX0+NmtgQ4E2gMXBe7y0kk3ZWUlvHX150P89Yz9IgOXDumn5rticQhnrOY3nL3E4H3kpCPSK3aWhg02/ty7Q7OPrYbZ3+9u5rticQpnq9R7cyspbvvTHg2IrVo2drtPDA5j+I9Zdx07gBGqJ+SSLXEUyB2AivMLBcoKp/o7mcnLCuRA/RB7jr++voi2rVqyu2XD+Gwg2t2HrhIQxZPgXg84VmI1JKySIR/vr2U6Z+vpm/X9tx47gBaNW+c6rRE6qRKC4SZDQAKgU/Di+RE0lbR7hL+/MI8Fq7YykkjDuOiE3qRlal+SiI1td+/HjO7muDA9PeAL8wsnn5JIimxemMRP33qM5as3sbVZ/Rh/Em9VRxEDlBlf0G3AgPcfSRwFvD95KQkUj2zfCO/+NssSsoifG/8MEYNOjTVKYnUC5XuYnL3teH/H5tZTnJSEolPJBrlpQ+W89KH+XQ/pA23nDeQ9q2bpjotkXqjsgKxb8vU0kQmIlIdu/eU8pdXFjBnyWaOHdCJK04zGjdSPyWR2lSdy0mT32NbpAIbt+5i4qQ81hXs4pITj+CkEYeRoYvfRGpdZQVikJntiHncInycAUTdvaYdXUVqbP7yLTz8YtBs77sXDaZ/NzXbE0mUygpEz6RlIVKFaDTKm5+t4p/vLOXQDi2ZcN5ADlazPZGE2m+BcPcVyUxEZH9KSst4+jXno3nrGdY7h2vH9KVZEzXbE0k0/ZVJWttauIcHJueyfF0h5369O2OO7aZmeyJJkpICYWbfB64G9gD/dPdfpCIPSW9L12znwcl5FJeUcct5AxnWW2daiyRT0i81NbOTCG41eiQwFBhpZuclOw9Jb+9/sZbf/H02TRpn8sPLh6s4iKRAKrYghgKvu/sOADN7DTgXmJyCXCTNlJZFeGRyLq98uJx+3dpzwzlqtieSKqkoELOB+8Lbl+4CziYFWzKSfgp37eXPL8xj0cptnHLk4VxwfE/1UxJJoYxoNPnXv5nZbcBVwBZgOnC0u4+pYrFuwPLEZiapsnztdn7+5Ey27ijmlgsGc8KILqlOSaS+6Q7kV2eBpG9BmFlrYJK7/yF8fCewLN7lCwqKiESSX9RyclqzaVOh4ibAZ4s28vjUBbRo2ojvjR/GyMGd6/2Y0yW2xlz/42ZmZpCdXbMbZqViF1N34K9mNgJoCVwT/pMGJhKN8sL7y3nlo3x6HtqGm88bSLtWarYnki6SXiDcPdfMJgG5QBZwn7t/mOw8JLV27ynlsZcXMHfpZr4+6BAuP8Vo3EjHG0TSSUqug3D3nwE/S0VsSb0NW3Zx/6RcNmzZzd/pdpUAABCxSURBVKUn9+aEYZ3VbE8kDelKakmqeV8W8PCL88nMzOD2iwbTV832RNKWCoQkRTQa5fWZq/jXjKV07tCKCeMGktOuearTEpFKqEBIwu0tKeOp1xbxyfwNDLccrjlTzfZE6gL9lUpCbdlRzMTJeaxYX8jYUd0Z87VuOt4gUkeoQEjCLFm9jQcn57G3NMKEcQMZeoT6KYnUJSoQkhDvzl3DM28sJrttM+4cP4jOHVqmOiURqSYVCKlVpWURnntrCe/MXkP/7gdxwzn9adlMzfZE6iIVCKk1O3bt5aEp81i8ahunjezC+cf1JDNTxxtE6ioVCKkVKzcUMnFSLtt3lnDdmH4cM6BTqlMSkQOkAiEHbObCDTwxdSEtmzfmB5cNo/shbVKdkojUAhUIqbFIJMqU979k6scr6NW5LTePHUBbNdsTqTdUIKRGdhWX8ujL88ldVsA3Bh/CpSer2Z5IfaMCIdW2rmAnEyflsWnbbi47pTfHD1WzPZH6SAVCqiV3WQGPvDSfrMwM7rh4CNalfapTEpEEUYGQuESjUV77dCX/nrGMww4Omu11aKtmeyL1mQqEVGlPSRlPvbqITxds4Mg+B/PNM/rStElWqtMSkQRLSYEws8uAH4QPX3X3O1KRh1StYHsxEyfnsmpDEeOO68EZR3fV8QaRBiLpBcLMWgD3A72BbcCHZnaSu09Pdi5SucWrtvHglDxKSiNMOH8QQ3p1SHVKIpJEqdiCyAIygZbATqAxsDsFeUglXv04n0cm59KhXXNuHTeQQ7LVbE+koUl6gXD3QjO7B1gE7ALeBT5Kdh5SsdKyCH+fvoQZc9YwsEc23zq7Hy3UbE+kQcqIRqNJDWhmg4CngVOB7cAzwEx3/20Vi3YDlic2u4ZtW+EefvX0TBYs38K443tx+Rn9yFKzPZH6ojuQX50FUrGL6VTgLXffCGBmTwE3AVUVCAAKCoqIRJJb1AByclqzaVNhvY27Yn0hEyfnUrirhOvP7sdZxx2RkvFC/X+t0ym2xlz/42ZmZpCd3apGy6aiQHwB/MbMWhLsYjoL+CwFeUjokwXreWraIlq1aMzdlw2na6fWqU5JRNJAKo5BvGFmQ4FZQAkwE/jfZOchQbO9Se8t49VPVnLEYW25eexA2rRskuq0RCRNpOQ6CHf/NfDrVMSWwK7iEh55aQF5XxYwemhnxp90BI2y1GxPRP5DV1I3QOsKdnL/pDw2b9vN5acaxw/tnOqURCQNqUA0MHOXbuaxl+fTKCuTOy8ZSu/D26U6JRFJUyoQDUQ0GmXaJyuY/O6XdOnYmlvOG0h222apTktE0pgKRAOwZ28ZT766kJkLNzKyX0euOr0PTRur2Z6IVE4Fop7bvH03D0zKY9XGIi4Y3ZPTRnZRsz0RiYsKRD3mK7fy4JR5lEWifPuCQQzqqWZ7IhI/FYh6KBqNMmPOGv4+fQk57Zpz6/mD6HRQi1SnJSJ1jApEPVNaFuGZNxbz3hdrGdQzm+vP6k+LZnqbRaT69MlRj2zfuZcHp+SxdPV2zjymK2NH9SBTzfZEpIZUIOqJ5et28MDkPHbuLuGGc/pzVN+OqU5JROo4FYh64OP563nq1UW0adGYuy8fTpeOarYnIgdOBaIOi0Si/HvGMl6buZLeh7fjprEDaNNCzfZEpHaoQNRRO4tLeOTF+cxbvoUThnXm4hPVbE9EapcKRB20dvNO7p+US8H2Yq48zThuiJrtiUjtU4GoY+Yu2cyjL8+nSeMs7ho/lCMOU7M9EUkMFYg6IhqN8srHK3jhvS/p0qk1E84byEFt1GxPRBIn6QXCzK4FbomZ1B34m7vfsp9FGrw9e8t4fNpCPl+0kaP7d+Sq0/rQRM32RCTBUnHL0b8AfwEws/7AC8C9yc6jrlhfsJNf/G0WazYXceHxvTj1qMPVbE9EkiLVu5j+DNzt7ptTnEdaWrxqW9BsryzCdy8YzIAe2alOSUQakIxoNJqSwGZ2EvArdz8yzkW6AcsTl1H6+d0zs/hy7XZ+dPVRHJrTKtXpiEjd1h3Ir84CqdyC+Bbwh+ouVFBQRCSS/KKWk9OaTZsKkxrz0pN60aljGzZvLkp67FSMN9WxNeaGEbuhxc3MzCA7u2ZfMFNyZZWZNQGOA15KRfy6olFWpo43iEjKpOrS20HAYnffmaL4IiJShVQViB7A6hTFFhGROKTkGIS7Pw88n4rYIiISH3V3ExGRCqlAiIhIhVQgRESkQqm+kro6soCU3mM5VbEbWtxUxtaYG0bshhQ3Jma1G7il7ErqGvg68H6qkxARqaNGAR9UZ4G6VCCaAkcC64CyFOciIlJXZAGHAJ8Be6qzYF0qECIikkQ6SC0iIhVSgRARkQqpQIiISIVUIEREpEIqECIiUiEVCBERqZAKhIiIVCgtW22Y2XjgR0Bj4I/u/uA+zw8B/gK0Ad4DbnD30iTE/THwTWBrOOmxfec5gNhtgI+AMe6ev89zCRlvnLETMuZwvReGD6e6+137PJ+wMccRO1Fj/ilwPhAFHnf3P+zzfCLHXFXshP1uh+v/HdDB3a/aZ3oX4BngYMCBS929qLbiVhH7SuB/gQ3hpKnu/sNaiPcOwXhKwknfcvdPY54/ieB2y82Bf7r7jw40ZjViP0nQlaL8Zm0/cfcp+1tf2hUIM+sM/AIYTnDV30dm9o67L4iZ7RngWnf/xMweB64D/pyEuCOAi9394wOJVUHskcBjQO/9zFLr461G7Fofc/gHcgowlOAD6zUzG7vPL2pCxhxn7ESM+TjgBIK7KTYGFpjZVHf3mNkSNeZ4YifkdzuMfyJwJTC1gqcfAh5y93+Y2T3APcD3khR7BHCbuz9Xi/EyCP6WulZU3M2sOfAEwS2XVwFTzex0d3810bFDI4BvuPu6eNaZjruYTgLedvct4S1J/03wzQcAM+sKNHf3T8JJTwEXJDpuaARwt5nlmtkDZtasFuJC8EFwM7B23ycSON4qY4cSMeZ1wO3uvtfdS4CFQJfyJxM85kpjh2p9zO7+LnB8+Id7MMGXs69uuZvIMVcVO5SQ320zO4jgi9cvK3iuMfANgr81qOXf7cpih44ErjSzPDN7xsza10bY8P83zOwLM7tln+ePApa4+/Lw/XiG2htzpbHNrAXB7/oT4fv8EzOrtAakY4E4lOCPuNw64LBqPJ+QuGbWCpgD3AkMA9oRfNs5YO5+rbvvrxFhosZbZexEjdnd55d/EJrZEQS7e6bFzJKwMVcVO8Hvc4mZ/QRYALwFrIl5OtHv835jJ3LMwCPAD/nPrqtYHYAdMd92a3XMVcQuj/czgi2rVcADtRCzPcHrOxY4EbjBzE6OeT6R73NVsTsBbxPsSjyaoHnfNZWtMO12MREUrdgGURlApBrPJyRuuF/0jPLHZvZ7gk3FA95neSB5JVKix2xm/Qk2/e909yUxTyV8zPuLnegxu/uPzezXwMsEW2+Phk8lfMz7i52oMZvZtcAqd3/LzK6qYJZ9xwy1NOY4YuPuY2Pm/w2w7EDjhrvovtpNF+4qPAN4M5yUsPe5qtju/iVB8Sh/fiJwBcEu5gql4xbEaoLOg+U68d+7P6p6PiFxzayLmX0z5vkM/nMgKJESNd4qJXLMZnYswbed77v70/s8ndAxVxY7UWM2sz7hQWjcfRcwmeCba7mEjbmq2Al8ny8CTjGzucBPgbPN7L6Y5zcCbc2s/D4Fh1B773Olsc2srZl9N2b+DKA2TnT5enjcI3a9sa9lIt/nSmOb2UAzG1dJbv9POhaI6cCJZpYT7jMbB7xW/qS7rwCKwz9ygMuBAz7AU1VcYDfwGzPrHh4MuhnY79H/2pLA8cYjIWM2s8OBF4Dx7v6PfZ9P5Jirik3i3ucewGNm1tTMmgDnENObP8Hvc6WxSdCY3f1kdx/g7kOA/wFecvfvxjxfQnCPl4vCSVdQS2OuKjZQBNwVnqQBcAu18z63A35rZs3MrDXBAfLY9X4KmJn1CgvjeGrvfa4qdgbwRzNrHx7/uZ4qxpx2BcLd1xBs2r4DzAX+7u4zzWyamY0IZ7sUuM/MFgGtgPsTHdfdNwHfItg8d4IX+/cHGnd/Ej3eeGIncMx3AM2AP5jZ3PDfDUkac6WxEzVmd59GsEtrDjAL+Cg8cyfhY64qdgp+t/9iZmeHD28CrjezBQT7xGvtlM/KYrt7GcHxpz+b2UKCsxfvqnzpqrn7K/z3a/2Eu38c/p4d6u7FwFXAJILjQYv4z0H6RMfOBX4FfBjGnlvVGVy6H4SIiFQo7bYgREQkPahAiIhIhVQgRESkQioQIiJSIRUIERGpUDpeSS0NiJndT9CPB6AfsJzgvHyAY9x9d4ULponwuoE3gfPdfVsC1p9FcMriKHcvrKV19gd+TnB9RAawBbjb3T+qjfVL/aHTXCVtmFk+wQft5ylOJW5m1ojgatT2iSgQtc3M+hJcRX6Fu08Pp50CPA8c7e6LUpmfpBdtQUhaC7/t/omgEVkWcJ+7P21B2+57CZqdHUFwZexvgFsJWh4/7+53hPP9lKCdgYXzXeXubmZNw2VGheueBXzb3QvNbDXB1caDCS6gyiRoQ90UyCG4COle4Mkw1ffN7FRgJsF9NeaG+a8GxoRxpwNLgcPDmL0J7kfQAigDfhxe1BY7/q8KEEF34TPDXHoSdGS9Yp+23eXL3UtwIVgpwcVYE9x9A3A3wb0eppfP6+5vWHAvlOIq3g5pYHQMQtJW2A7gXwTtuYcDo4EfxFx5PBL4WdhOYTdBN9LTCVpXf8fMDo6Z7w/uPhB4Fijvv/TDcLnh7j4Y2EzQHrrcF+7el+Dq1NuBy8I8jgXusaA99NXhvKPcvaqeOl2Be9zdCArC4wQtP4YRNFF71Myq6ux5HHCjuw8AZlPB1b9mdh1BN88R7j4IWBzGInxtPtx3GXef5vvcLEpEWxCSzvoS7Cd/2qy81T1NCW72sxxYGrYPgKAT54awv89GMysCDgqfmxWzf/0vwP1m1pbgm30r4LRw/U3478Zp7wO4e8TMzgTGmNnlBMdKMgi++VfnuMBegl48EBSZQ4CXYsYWAQYQNHTbn89iCtFsYrqwxjidYAtnV/j4T8DqcGskgr4YSpxUICSdZQEF4RYCAGbWCdhGcNvEPfvMv7/OlLFdOss/HMvC9d/s7m+G625NUCTKFcVMn0PQM+cDglbY5xEUiX1F95keu77d7l7e2jkLyHP38uZ85Xc13LifMXy1jkpilcviv1tKZxLcSQ7gE4J7AcQ2osSCe0Us3E8DQ2mg9E1C0tkCIGJmF8NXd12bT3BcoDqGh8cyIGhK9254D4TXgQlm1jg8W+gJgrN79mUEWwv3hA3RTiT4cpVFUGii/OcDeBPBbpzy25vm7Cenj4B+5d1bzWwYwa6gjtUcW0VeA64JuxJDcFzmnfDGPL8BboxtC21mZxB0M/2iFmJLPaICIWnL3fcAZxN8oOUSfPB932Nuwh6ndcCvzWwewS6ZK8Pp9xLszplLUHhKCI5j7GsO8AawKOz8eRrBgd9e7h4l6Mz5QXiG0F3AHRbch+CicN0VjW0DwUHn+8zsC4LbbY5398p2L8XrEeA94LOwM+wAglbahAe0zwa+b8FtJ+cTdLg9090X1kJsqUd0mqvUa+G3+N/F7qYSkfhoC0JERCqkLQgREamQtiBERKRCKhAiIlIhFQgREamQCoSIiFRIBUJERCqkAiEiIhX6P/dwbz62La+gAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x,y)\n",
    "plt.xlabel('Temperature in oC')\n",
    "plt.ylabel('Pressure in atm')\n",
    "plt.title('Temperature vs Pressure')\n",
    "plt.xticks(np.arange(0, 6, step=0.5))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0, 0.5, 'y'), Text(0.5, 0, 'x')]"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.random.normal(size=1000)\n",
    "ax = sns.distplot(x);\n",
    "ax.set(xlabel=\"x\", ylabel='y')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Summery\n",
    "\n",
    "To summarise, the main differences with python lists are:\n",
    "\n",
    "1. Arrays support vectorised operations, while lists don’t.\n",
    "1. Once an array is created, you cannot change its size. You will have to create a new array or overwrite the existing one.\n",
    "1. Every array has one and only one dtype. All items in it should be of that dtype.\n",
    "1. An equivalent numpy array occupies much less space than a python list of lists.\n",
    "1. numpy arrays support boolean indexing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}