DATA ANALYSIS COURSE WORK.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DATA ANALYSIS WITH PYTHON\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "dat = {i: np.random.randn() for i in range(7)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0.49042022535801333,\n",
       " 1: 0.2431145213381427,\n",
       " 2: 0.8367838696275055,\n",
       " 3: 0.23424384998313216,\n",
       " 4: -0.5151739166655485,\n",
       " 5: 0.7770222835447722,\n",
       " 6: -0.4244864885047254}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 0.49042022535801333, 1: 0.2431145213381427, 2: 0.8367838696275055, 3: 0.23424384998313216, 4: -0.5151739166655485, 5: 0.7770222835447722, 6: -0.4244864885047254}\n"
     ]
    }
   ],
   "source": [
    "print(dat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### DOCSTRINGS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_numbers(a, b):\n",
    "    \"\"\"\n",
    "    Add two numbers together\n",
    "    Returns\n",
    "    -------\n",
    "    the_sum : type of arguments\n",
    "    \"\"\"\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function str.split(sep=None, maxsplit=-1)>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getattr('foo', 'split')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = '''\n",
    "jsjhsfhdhgfh\n",
    "hjdsfhgdshgfh\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.count('\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**STRING FORMATTING**\n",
    "====================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.455 Maswa is 345\n"
     ]
    }
   ],
   "source": [
    "draft = '{0:.3f} {1:s} is {2:d}'.format(3.45468903, 'Maswa',345)\n",
    "print(draft)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ENCODING AND DECODING STRINGS TO AND FROM UNICODE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this bl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "STR = 'español'\n",
    "encoded = STR.encode('utf-8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'espa\\xc3\\xb1ol'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "encoded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bytes"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(encoded)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "decoda = encoded.decode('utf-8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'español'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decoda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'espa\\xf1ol'\n"
     ]
    }
   ],
   "source": [
    "print(decoda.encode('latin1'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'\\xff\\xfee\\x00s\\x00p\\x00a\\x00\\xf1\\x00o\\x00l\\x00'\n"
     ]
    }
   ],
   "source": [
    "print(decoda.encode('utf-16'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'e\\x00s\\x00p\\x00a\\x00\\xf1\\x00o\\x00l\\x00'\n"
     ]
    }
   ],
   "source": [
    "print(decoda.encode('utf-16le'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TERNARY OPERATORS\n",
    "===================\n",
    "are used to shorten an if-else statement that produces a value into a single line, eg. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'EXCITED'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c='smile'\n",
    "'EXCITED' if c == 'smile' else 'SAD'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TUPLES\n",
    "------------\n",
    "are immutable but if an object in a tuple such as a list is mutable then you do the following;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 'marcy', 77, [4, 6, 7, 34], 'sassy')"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup = (4,'marcy',77,[4,6,7],'sassy')\n",
    "tup[3].append(34)\n",
    "tup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "see that the value in the list was changed cause it is mutable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unpacking tuples\n",
    "-------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a,b,c,d,e = tup\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'marcy'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "77"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 6, 7, 34]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'sassy'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice all the values in the tuple has not unpacked to the variables in their respective position in the tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i=3 j=4 k=5\n",
      "i=3 j=6 k=8\n"
     ]
    }
   ],
   "source": [
    "a_seq = [(3,4,5),(3,6,8)]\n",
    "for i,j,k in a_seq:\n",
    "    print('i={0} j={1} k={2}'.format(i,j,k))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "UNPACKING TUPLE VALUES WITH *\n",
    "----------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "7\n",
      "[4, 66, 44, 7, 4, 0]\n"
     ]
    }
   ],
   "source": [
    "a_tup = (6,7,4,66,44,7,4,0)\n",
    "a,b,*_ = a_tup\n",
    "print(a)\n",
    "print(b)\n",
    "print(_) #* automatically assigns the remaining values in the tup in a list-like format to the variable following *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_tup.count(4) #counting the number of times 4 appears in the tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SORTING LISTS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ama', 'bag', 'tree', 'zipper', 'socrito']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list = ['ama','zipper','bag','tree','socrito']\n",
    "a_list.sort(key=len)     #re-orders the list according to the length of each word\n",
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ama', 'bag', 'socrito', 'tree', 'zipper']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list.sort()    #re-orders the list alphabetically\n",
    "a_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "BINARY SEARCH AND MAINTAINING SORTED LIST\n",
    "==================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import bisect\n",
    "an_arr = [4,5,3,88,5,7,9,4,3,5,7,5]\n",
    "bisect.bisect(an_arr,7)    #finds the location where a value would be inserted in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 5, 3, 88, 5, 7, 9, 4, 3, 5, 7, 5]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bisect.insort(an_arr, 3)     #inserts a value to a list in that location\n",
    "an_arr "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 6, 7, 2]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq = [7, 2, 3, 7, 5, 6, 0, 1]\n",
    "seq[::-2]    #reverse count in two's"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 0, 6, 5, 7, 3, 2, 7]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq[::-1]     #reverse list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PYTHON ENUMERATE\n",
    "==\n",
    "#### used to keep track of the index of a value during iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "indexed 7\n"
     ]
    }
   ],
   "source": [
    "for i,v in enumerate(range(8)):          #the first value is used as the index value.\n",
    "    print(v)\n",
    "print('indexed',i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'gre': 0, 'foo': 1, 'bar': 2, 'api': 3}"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_dict={}\n",
    "_list = ['gre','foo','bar','api']\n",
    "for idx,val in enumerate(_list):\n",
    "    a_dict[val]=idx\n",
    "a_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SORTED\n",
    "*RETURNS A NEW SORTED LISTED OF VALUES IN ANY SEQUENCE*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['api', 'bar', 'foo', 'gre']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "    sorted(_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[' ', 'B', 'R', 'a', 'a', 'a', 'b', 'e', 'h', 'i', 'l', 'm', 'p']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted('Raphael Bambi')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 3, 3, 4, 6, 7, 7, 8]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted([3,7,4,0,8,3,7,6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ZIP\n",
    "---\n",
    "### combines values in tuplues,lists in their exact position into list of tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('max', 'den'), ('diff', 'soy'), ('sum', 'add'), ('pen', 'axe')]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_one = ['max','diff','sum','pen']\n",
    "list_two = ['den','soy','add','axe']\n",
    "a_zip = zip(list_one,list_two)\n",
    "this = list(a_zip)\n",
    "this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: --- max --- den\n",
      "1: --- diff --- soy\n",
      "2: --- sum --- add\n",
      "3: --- pen --- axe\n"
     ]
    }
   ],
   "source": [
    "#using zip and enumerate to iterate through multiple sequences\n",
    "for i,(a,b) in enumerate(zip(list_one,list_two)):\n",
    "    print('{0}: --- {1} --- {2}'.format(i,a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "#unzip zipped values\n",
    "one, two = zip(*this)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('max', 'diff', 'sum', 'pen')"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('den', 'soy', 'add', 'axe')"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'another value'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dd ={'a': 'some value',\n",
    "'b': [1, 2, 3, 4],\n",
    "7: 'an integer',\n",
    "'dummy': 'another value'}\n",
    "red = dd.pop('dummy')     #this removes dummy from the dict and assigns its value to the variable, 'red'\n",
    "red\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer'}"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "dd.update({'dee': [3, 4],\n",
    "'rrr': 'ande',})     #merge dictionaries using the update function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'some value',\n",
       " 'b': [1, 2, 3, 4],\n",
       " 7: 'an integer',\n",
       " 'dee': [3, 4],\n",
       " 'rrr': 'ande'}"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "USING ZIP TO MAP KEY AND VALUES FROM TWO LISTS\n",
    "======="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'some value',\n",
       " 'b': [1, 2, 3, 4],\n",
       " 7: 'an integer',\n",
       " 'dee': [3, 4],\n",
       " 'rrr': 'ande'}"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "key = dd.keys()\n",
    "values = dd.values()\n",
    "mapping={}\n",
    "for k,x in zip(key, values):\n",
    "    mapping[k]=x\n",
    "mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 7, 1: 6, 2: 5, 3: 4, 4: 3, 5: 2, 6: 1, 7: 0}"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mapp = dict(zip(range(8), reversed(range(8))))    \n",
    "\"\"\"\n",
    "this creates two lists for numbers between 0 and 8\n",
    "in the first list, and the reverse order of numbers\n",
    "between 0-8 in the second list, then maps them together\n",
    "in their respective position and makes them key&value\n",
    "pairs of the dict then assigns it to mapp.\n",
    "\"\"\"\n",
    "mapp\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SETS\n",
    "--------\n",
    "### are unordered collections of unique elements like the dict but with no value pair used in mathematical operations like the mathematically sets "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "at = {1, 2, 3, 4, 5,9}\n",
    "bt = {4,5,6,7,8,1, 2, 3, 4, 5}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### UNION OF SETS\n",
    "combining the values of sets into one "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7, 8, 9}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "at|bt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7, 8, 9}"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "at.union(bt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### INTERSECTION OF SETS\n",
    "consists of similar values in sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "at & bt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "at.intersection(bt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DIFFERENCE OF SETS\n",
    "picks elements in at that are not in bt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{9}"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "at.difference(bt)  #where there is no difference it returns set()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{9}"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "at-bt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "at.issubset(bt)    #checks that the elements in at are all in bt "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "at.issuperset(bt)   #checks that the elements in bt are contained in at"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "at.isdisjoint(bt)    #checks for the occurrence of common elements in at & bt and returns where there are none "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{6, 7, 8, 9}"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "at^bt   #returns elements that are not in bt but at and vice versa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "at.symmetric_difference_update(bt)    #sets the values in at to the values returned from at^bt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{6, 7, 8, 9}"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "at"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{6, 7, 8, 9}"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ct = at.copy()\n",
    "ct"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LIST COMPREHENSION\n",
    "========\n",
    "### [expr for val in collection if condition]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['TREE', 'ZIPPER', 'SOCRITO', 'COCO']"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#This\n",
    "string_vals = ['ama', 'bag', 'tree', 'zipper', 'socrito','coco','at']\n",
    "a_list = []\n",
    "for x in string_vals:\n",
    "    if len(x) > 3:\n",
    "        a_list.append(x.upper())\n",
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['TREE', 'ZIPPER', 'SOCRITO', 'COCO']"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#can be re-written as;\n",
    "[x.upper() for x in string_vals if len(x)>3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SIMPLE IMPLEMENTATION OF DATA CLEANING\n",
    "-----------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "states = ['Alabama ', 'Georgia!', 'Georgia', 'georgia', 'FlOrIda', 'south carolina##', 'West virginia?']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Alabama',\n",
       " 'Georgia',\n",
       " 'Georgia',\n",
       " 'Georgia',\n",
       " 'Florida',\n",
       " 'South Carolina',\n",
       " 'West Virginia']"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import re\n",
    "def clean_strings(strings):\n",
    "    result = []\n",
    "    for value in strings:\n",
    "        value = value.strip()     #remove whitespaces\n",
    "        value = re.sub('[!#?]', '', value)     #replace the occurrences of !#? with nothing\n",
    "        value = value.title()   #change case to titlecase\n",
    "        result.append(value)     #append the values to result\n",
    "    return result\n",
    "\n",
    "clean_strings(states)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Alabama',\n",
       " 'Georgia',\n",
       " 'Georgia',\n",
       " 'Georgia',\n",
       " 'Florida',\n",
       " 'South Carolina',\n",
       " 'West Virginia']"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def remove_punctuation(value):\n",
    "    '''\n",
    "    takes in values and removes occurrences of the\n",
    "    following characters and returns the new value\n",
    "    '''\n",
    "    return re.sub('[!#?]', '', value)\n",
    "\n",
    "clean_ops = [str.strip, remove_punctuation, str.title]  \n",
    "'''\n",
    "Calls the remove_punctuation function, then\n",
    "changes the case to title case \n",
    "then removes whitespaces and returns a new value saved to clean_ops\n",
    "'''\n",
    "\n",
    "def clean_strings(strings, ops):\n",
    "    '''\n",
    "    takes in a list of strings and a function \n",
    "    then for each string it calls the function on the string\n",
    "    appends the new value to the result list and returns the result\n",
    "    '''\n",
    "    result = []\n",
    "    for value in strings:\n",
    "        for function in ops:\n",
    "            value = function(value)\n",
    "        result.append(value)\n",
    "    return result\n",
    "\n",
    "clean_strings(states, clean_ops) #uses the array,'states' and the clean_ops function as args for the clean_strings function\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LAMBDA\n",
    "---------\n",
    "\n",
    "#### so-called anonymous or lambda functions, which are a way of writing functions consisting of a single statement, the result of which is the return value. They are defined with the lambda keyword, which has no meaning other than declaring an anonymous function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "equiv_lamba = lambda x: x * 2    #would be same as;\n",
    "def lamba_example(x):\n",
    "    return x*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 0, 2, 10, 12]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def apply_to_list(some_list, f):\n",
    "    return [f(x) for x in some_list]\n",
    "ints = [4, 0, 1, 5, 6]\n",
    "apply_to_list(ints, lambda x: x * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['fan', 'cook', 'ping', 'pies', 'babaand', 'badadaass', 'darkchoco']"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stringd = ['fan','babaand','badadaass','cook','ping','pies','darkchoco']\n",
    "stringd.sort(key=len)     #sorts the list using their len\n",
    "stringd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['fan', 'cook', 'ping', 'pies', 'babaand', 'badadaass', 'darkchoco']"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "suppose you wanted to sort a collection of strings by the number\n",
    "of distinct letters in each string\n",
    "\"\"\"\n",
    "stringd.sort(key=lambda x: len(set(list(x))))\n",
    "stringd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CURRYING \n",
    "-----------------\n",
    "### means deriving new functions from already existing ones by\n",
    "***partial argument application***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "def addition(x,y):\n",
    "    \"\"\"\n",
    "this returns a function.\n",
    "Here the addition is curried\n",
    "\"\"\"\n",
    "    return x+y\n",
    "five_add = lambda x: addition(x,5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "functools.partial(<function addition at 0x7f1706632ca0>, 5)"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "the above can be repeated using the functools module\n",
    "\"\"\"\n",
    "from functools import partial\n",
    "five_add = partial(addition, 5)\n",
    "five_add"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "GENERATORS\n",
    "-----------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A python iterator protocol provides consistent/generic ways of iterating over a sequence like objects in a list or lines.\n",
    "#### An iterator is an object that yields objects to the python interpreter when used on a sequence of objects.\n",
    "#### Most methods expecting lists or list-like sequence use any iteerable object, built-in methods like min,max,sum and type constructors like list and tuple.\n",
    "\n",
    "Generators \n",
    "------------\n",
    "#### unlike the regular python functions that return a single result per time, generators provides a way to construct a new iterable object that returns a sequence of multiple results lazily, pausing after each one until the next one is requested. They are created using the yield keyword inplace of the usual return used in functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object example_gen at 0x7f1706652ac0>"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def example_gen(n=9):\n",
    "    \"\"\"\n",
    "when the example_gen function is called, \n",
    "no code is executed but it returns an object\n",
    "\"\"\"\n",
    "    print('Generating cubes from 1 to {0}'.format(n ** 3))\n",
    "    for x in range(1, n + 1):\n",
    "        yield x ** 3\n",
    "example_gen()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating cubes from 1 to 729\n",
      "1 8 27 64 125 216 343 512 729 "
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "but by requesting elements from the generator the code is executed\n",
    "for example,\n",
    "\"\"\"\n",
    "for y in example_gen(): \n",
    "    print(y, end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generator expressions \n",
    "-------------\n",
    "just like with list, set and dict comprehension, generators can be created in a more concise way using generator expressions by enclosing similar to list comprehension values within parentheses instead of square brackets.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0,\n",
       " 1,\n",
       " 8,\n",
       " 27,\n",
       " 64,\n",
       " 125,\n",
       " 216,\n",
       " 343,\n",
       " 512,\n",
       " 729,\n",
       " 1000,\n",
       " 1331,\n",
       " 1728,\n",
       " 2197,\n",
       " 2744,\n",
       " 3375,\n",
       " 4096,\n",
       " 4913,\n",
       " 5832,\n",
       " 6859,\n",
       " 8000,\n",
       " 9261,\n",
       " 10648,\n",
       " 12167,\n",
       " 13824,\n",
       " 15625,\n",
       " 17576,\n",
       " 19683,\n",
       " 21952,\n",
       " 24389,\n",
       " 27000,\n",
       " 29791,\n",
       " 32768,\n",
       " 35937,\n",
       " 39304,\n",
       " 42875,\n",
       " 46656,\n",
       " 50653,\n",
       " 54872,\n",
       " 59319]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "generator = (x**3 for x in range(40))\n",
    "generator\n",
    "#like said earlier to execute the code, request elements from generators, therefore\n",
    "[y for y in generator]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 8, 27, 64, 125, 216, 343, 512, 729, 1000, 1331, 1728, 2197, 2744, 3375, 4096, 4913, 5832, 6859, 8000, 9261, 10648, 12167, 13824, 15625, 17576, 19683, 21952, 24389, 27000, 29791, 32768, 35937, 39304, 42875, 46656, 50653, 54872, 59319]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "the above code, is therefore equivalent to\n",
    "'''\n",
    "def _gen_ex():\n",
    "    for x in range(40):\n",
    "        yield x**3\n",
    "\n",
    "gen_list=[]\n",
    "for x in _gen_ex():\n",
    "    gen_list.append(x)\n",
    "print(gen_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1755"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "other examples of using list comprehensions with builtin methods\n",
    "like sum and type constructors like dict\n",
    "'''\n",
    "sum(((k+5)*3) for k in range(30))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0,\n",
       " 1: 1,\n",
       " 2: 8,\n",
       " 3: 27,\n",
       " 4: 64,\n",
       " 5: 125,\n",
       " 6: 216,\n",
       " 7: 343,\n",
       " 8: 512,\n",
       " 9: 729,\n",
       " 10: 1000,\n",
       " 11: 1331,\n",
       " 12: 1728,\n",
       " 13: 2197,\n",
       " 14: 2744,\n",
       " 15: 3375,\n",
       " 16: 4096,\n",
       " 17: 4913,\n",
       " 18: 5832,\n",
       " 19: 6859,\n",
       " 20: 8000,\n",
       " 21: 9261,\n",
       " 22: 10648,\n",
       " 23: 12167,\n",
       " 24: 13824,\n",
       " 25: 15625,\n",
       " 26: 17576,\n",
       " 27: 19683,\n",
       " 28: 21952,\n",
       " 29: 24389}"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict((d, d **3) for d in range(30))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ITERTOOLS MODULE\n",
    "-----------\n",
    "### has a collection of generators for many common data algorithms. For example, groupby takes any sequence and a function, grouping consecutive elements in the sequence by return value of the function, FOR EXAMPLE;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R ['Raphael']\n",
      "N ['Noriode']\n",
      "A ['Alan', 'Adler']\n",
      "B ['Brux']\n",
      "S ['Simeon']\n",
      "C ['Cassie', 'Charles']\n",
      "M ['Mary', 'Mavy']\n"
     ]
    }
   ],
   "source": [
    "import itertools\n",
    "'''\n",
    "this lambda function is same as \n",
    "def afunc(x):\n",
    "    return x[0].\n",
    "    \n",
    "The groupby groups closely situated words with same first letter together\n",
    "in a list, while lambda function returns the first letter of each group\n",
    "'''\n",
    "first_letter = lambda x: x[0]   #this checks for the first letter and returns it\n",
    "names = ['Raphael','Noriode','Alan','Adler','Brux','Simeon','Cassie','Charles','Mary','Mavy']\n",
    "for letter, name in itertools.groupby(names, first_letter):\n",
    "    print(letter, list(name))   #note: name is a generator and has to be requested for execution.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Note: when handing errors/exceptions, in cases where you want some code to be executed regardless of whether the code in the try block succeeds or not, use finally;\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    open_file = open('afile.txt','w')\n",
    "    open_file.write('some_string')\n",
    "except:\n",
    "    print('error')\n",
    "else:\n",
    "    print('Done')\n",
    "finally:\n",
    "    open_file.close()\n",
    " #the file would get closed whether the code fails or succeeds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy array\n",
    "---------------\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.42534378,  1.67101612, -0.91334337, -0.62054435, -1.03031462],\n",
       "       [ 0.13800081, -0.00722204, -1.23886814,  0.06670894, -2.03428087],\n",
       "       [ 0.51372117, -0.69034939, -0.2139756 , -0.81948025,  0.49791958]])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "dataset =  np.random.randn(3,5)\n",
    "dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-0.4253437780335604,\n",
       " 1.6710161202202745,\n",
       " -0.9133433659693954,\n",
       " -0.6205443529745375,\n",
       " -1.0303146190362462,\n",
       " 0.13800081173299586,\n",
       " -0.007222041117679059,\n",
       " -1.2388681392637755,\n",
       " 0.0667089408499451,\n",
       " -2.034280868537741,\n",
       " 0.5137211706995911,\n",
       " -0.6903493915671436,\n",
       " -0.2139755975428382,\n",
       " -0.8194802470814829,\n",
       " 0.49791957653006164]"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x for y in dataset for x in y]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ndarray\n",
    "-----\n",
    "### is a generic multidimensional container for data of the same type, that has a .shape, a tuple that determines its' dimensions and a dtype that shows its' data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 5)"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#for example;\n",
    "dataset.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating ndarrays\n",
    "#### ndarrays are created using the array function which accepts any sequence like object like lists.\n",
    "for example;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4,  6,  4],\n",
       "       [ 4,  3,  3],\n",
       "       [44, 65,  4],\n",
       "       [ 5,  6,  8]])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "this creates a multidimensional numpy array\n",
    "note: all nested arrays must be of the same dimension\n",
    "else an error would be raised\"\"\"\n",
    "arr = [[4,6,4],[4,3,3],[44,65,4],[5,6,8]]\n",
    "nd_arr = np.array(arr)\n",
    "nd_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 3)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "to know the number of arrays created, you can use \n",
    ".ndim to view this\"\"\"\n",
    "nd_arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nd_arr.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nd_arr.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CREATING NUMPY ARRAYS USING ZEROS, ONES, arange AND EMPTY FUNCTIONS.\n",
    "-----------------\n",
    "- numpy zeros function creates an ndarray of 0's.\n",
    "- numpy ones creates an array of 1s.\n",
    "- arange is an array-valued version of the python range function.\n",
    "- empty creates an array withput initializing its value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(9)  #this creates a one-dimensional array of 0's."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((3,5))   #this creates a multi-dimensional array of ones  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[4.68170696e-310, 0.00000000e+000],\n",
       "        [0.00000000e+000, 0.00000000e+000],\n",
       "        [0.00000000e+000, 0.00000000e+000]],\n",
       "\n",
       "       [[0.00000000e+000, 0.00000000e+000],\n",
       "        [0.00000000e+000, 0.00000000e+000],\n",
       "        [0.00000000e+000, 0.00000000e+000]]])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.empty((2, 3, 2))   #creates two multi-dimensional arrays with no particular datatype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(12)   #this creates a list from 0 - 11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Specifying the datatype of ndarrays using dtype\n",
    "----------------\n",
    "- dtypes are a source of NumPy’s flexibility for interacting with data coming from other systems, they provide a mapping directly onto an underlying disk or memory representation, which makes it easy to read and write binary streams of data to disk and also to connect to code written in a low-level language like C or Fortran.\n",
    "- The numerical dtypes are named the same way: a type name, like float or int , followed by a number indicating the number of bits per element.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr_one = np.array([4,6,4,3,5,5,6], dtype = np.float64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_one.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "EXPLICITLY CONVERTING AN ARRAY FROM ONE TYPE TO ANOTHER USING .astype()\n",
    "-------------------------\n",
    "- Calling astype always creates a new array (a copy of the data), even if the new dtype is the same as the old dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int_arr = arr_one.astype(np.int64)\n",
    "int_arr.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "casting a float to int truncates the decimal part,\n",
    "that is, the integer part only is in the array\n",
    "for example;\n",
    "\"\"\"\n",
    "disArr = np.array([3.44,4.6,6,7.7,3.5], dtype = np.float64)\n",
    "disArr = disArr.astype(np.int64)\n",
    "disArr.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 6, 7, 3])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "disArr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CONVERTING AN ARRAY OF NUMERICAL STRING TO NUMERIC FORM\n",
    "------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([b'44', b'44.0', b'4.6', b'6.5', b'9.0'], dtype='|S4')"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"to convert an array of numerical strings to numeric form\n",
    "you use the astype() function\n",
    "for example;\"\"\"\n",
    "\n",
    "num_str = np.array(['44','44.0','4.6','6.5','9.0'], dtype = np.string_)\n",
    "num_str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([44. , 44. ,  4.6,  6.5,  9. ])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_str.astype(np.float64)   #using float inplace of np.float64 causes Numpy to use the python type equivalent to its dtype."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "USING THE DTYPE OF AN ANOTHER ARRAY ON A DIFFERENT ARRAY\n",
    "----------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int_arr = np.arange(9)\n",
    "anoda_arr = np.array(['44','44.0','4.6','6.5','9.0'], dtype = np.float64)\n",
    "int_arr.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3., 4., 5., 6., 7., 8.])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int_arr = int_arr.astype(anoda_arr.dtype)  #this converts the type of the int_arr to float the dtype of anoda_arr\n",
    "int_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#to view the dtype of the int_arr\n",
    "int_arr.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 1, 1], dtype=uint64)"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Using shorthand code strings torefer to a \n",
    "dtype\n",
    "\n",
    "u8 specifies an unsigned 8-bit(1 byte) integer type\"\"\"\n",
    "\n",
    "ones=np.ones(5, dtype = 'u8')\n",
    "ones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ARITHMETIC OPERATIONS WITH NUMPY ARRAYS\n",
    "------------------\n",
    "### Vectorization: is the ability of arrays to perform batch operations on data without the for-loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4, 5, 6],\n",
       "       [6, 4, 9],\n",
       "       [3, 5, 5]])"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Any arithmetic\n",
    "operations between\n",
    "equal-size arrays applies the operation element-wise\n",
    "\"\"\"\n",
    "een_arr = np.array([[4,5,6],[6,4,9],[3,5,5]])\n",
    "een_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[16, 25, 36],\n",
       "       [36, 16, 81],\n",
       "       [ 9, 25, 25]])"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "een_arr * een_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "een_arr /een_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.25      , 0.2       , 0.16666667],\n",
       "       [0.16666667, 0.25      , 0.11111111],\n",
       "       [0.33333333, 0.2       , 0.2       ]])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"performing arithmetic operations with scalars result\n",
    "in scalar args to the elements in the array, example;\n",
    "\"\"\"\n",
    "1 / een_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[ True, False,  True],\n",
       "        [False,  True, False],\n",
       "        [ True,  True,  True]]),\n",
       " dtype('bool'))"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"Comparing arrays of same size yield\n",
    "boolean arrays, example;\n",
    "\"\"\"\n",
    "vijf_arr= np.array([[0.25,67, 0.16666667],[9, 0.25, 40],[0.33333333, 0.2,0.2]])\n",
    "k = een_arr > vijf_arr\n",
    "k, k.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "INDEXING AND SLICING IN NUMPY ARRAYS\n",
    "-----------\n",
    "Just like with python arrays, numpy arrays also can be sliced."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "this_arr = np.arange(11)\n",
    "this_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5, 6, 7, 8])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "this_arr[4:9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3, 33, 33, 33, 33, 33,  9, 10])"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "one value can be assigned to a slice and cause a slice is a view of the array,\n",
    "the changes are also effected in the array, this is known as BROADCASTING. example;\n",
    "\"\"\"\n",
    "this_arr[4:9] = 33\n",
    "this_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   0,    1,    2,    3,   33,   33,   33, 7085,   33,    9,   10])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "the values in the sliced array can also be altered and this \n",
    "would also affect the original array,\n",
    "cause all slices are views to the actual array\n",
    "\"\"\"\n",
    "change_arr = this_arr[4:9]\n",
    "change_arr[3] = 7085\n",
    "this_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   0,    1,    2,    3,   33,   33,   33, 7085,   33,    9,   10])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"inorder to actually get a copy f a slice from a numpy array, \n",
    "you would have to explicitly copy the array with the .copy() method\n",
    "for example,\"\"\"\n",
    "change_arr = this_arr[4:9].copy()\n",
    "change_arr[3]=30098\n",
    "this_arr    #notice that this doesn't change the actual array cause change_arr is a copy and not a view"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   33,    33,    33, 30098,    33])"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "but the change_arr was actually altered\n",
    "as seen here\"\"\"\n",
    "change_arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SLICING MULTI-DIMENSIONAL ARRAY\n",
    "----------\n",
    "conventionally elements in python multi-dimensionsal arrays, are accessed recursively for example;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arrd = np.array([[1, 2, 3], [4, 5, 6],[5,8,4],[9,4,7]])\n",
    "#to access the third element in the second array,6 you would;\n",
    "\n",
    "arrd[1][2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "But with numpy arrays, slicing can be done with\n",
    "comma seperated values for example;\n",
    "'''\n",
    "arrd[1, 2]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Muilti-dimensional when put in tabular form can thought of like axis of a table where axis A is \"rows\" and axis B is \"columns\".\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr3d = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])\n",
    "arr3d[0,1,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr3d[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[33, 33, 33],\n",
       "       [33, 33, 33]])"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Just like done in one-dimensional array, the elements in a\n",
    "multi-dimensional can be sliced/indexed and changed\n",
    "as seen here.\n",
    "To change the elements of the second array in the arrd\n",
    "\"\"\"\n",
    "\n",
    "arr3d[0] = 33   #changes all elements in the first array\n",
    "arr3d[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[33, 33, 33],\n",
       "        [33, 33, 33]],\n",
       "\n",
       "       [[ 7,  8,  9],\n",
       "        [10, 11, 12]]])"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"this alters the content of the first multi-dimensional array \n",
    "cause the array was mirrored and not copied, the initial array\n",
    "\"\"\"\n",
    "arr3d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[33, 33, 33],\n",
       "       [33, 33, 33]])"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "to change the value without altering the inital array \n",
    "you copy the array or element and make the changes\n",
    "\"\"\"\n",
    "copyarr = arr3d[0].copy()\n",
    "copyarr "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[43, 43, 43],\n",
       "       [33, 33, 33]])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "copyarr[0] = 43\n",
    "copyarr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[33, 33, 33],\n",
       "        [33, 33, 33]],\n",
       "\n",
       "       [[ 7,  8,  9],\n",
       "        [10, 11, 12]]])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#notice the values of an array the initial does not change\n",
    "arr3d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing multi-dimensional arrays\n",
    "------------------\n",
    "just like python arrays, numpy arrays can also be indexed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3, 4)"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr4d = np.array([[[3,5,3,2], [34,5,6,1],[23,6,44,8]],\n",
    "        [[44,3,5,7],[18,9,21,12],[78,5,6,14]]])\n",
    "arr4d.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 3,  5,  3,  2],\n",
       "        [34,  5,  6,  1],\n",
       "        [23,  6, 44,  8]]])"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr4d[:1]    #this returns the first multi-dimensional "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[564, 564,   3,   2],\n",
       "        [564, 564,   6,   1],\n",
       "        [564, 564,  44,   8]],\n",
       "\n",
       "       [[ 44,   3,   5,   7],\n",
       "        [ 18,   9,  21,  12],\n",
       "        [ 78,   5,   6,  14]]])"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "all conditions applying to previous arrays apply to this \n",
    "that is, to copy, .copy() method is used\"\"\"\n",
    "arr4d[:1, :, :2] = 564\n",
    "arr4d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "BOOLEAN INDEXING OF NDARRAYS\n",
    "----------------\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False,  True,  True, False, False, False])"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Here we would specify an array of random numbers\n",
    "and an array of words, then check for corresponding occurrences\n",
    "of a word, then index the arr of numbers using the boolean array\n",
    "returned from the check.\n",
    "\"\"\"\n",
    "rand_arr = np.random.randn(7, 3)   #a 3 x 5 array\n",
    "name_arr = np.array(['Bob','Foo','Bob','Bob','Sam','Joe','Rex'])\n",
    "#to check elements corresponding to 'Bob' in nam_arr\n",
    "name_arr == 'Bob'   #this returns an array of boolean values, true values for all correspoding cases\n",
    "#and false for all negative cases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.0916526 , -0.04189856, -0.61770741],\n",
       "       [ 1.40271386,  0.43379107,  1.16571544],\n",
       "       [-0.18208768,  0.91992037, -0.1926417 ],\n",
       "       [ 1.62845325,  1.93125694, -0.29817573],\n",
       "       [ 1.72086647, -0.73101699, -0.45257566],\n",
       "       [ 2.60302456,  0.34744254,  0.5996749 ],\n",
       "       [ 1.75175897,  0.66898376,  1.45171949]])"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "the length of the arr must be same as the array indexing it\n",
    "here the returned array is 7 in length, which is why I initialized\n",
    "a 7 x 3 array, else this results in an error.\n",
    "\"\"\"\n",
    "rand_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.0916526 , -0.04189856, -0.61770741],\n",
       "       [-0.18208768,  0.91992037, -0.1926417 ],\n",
       "       [ 1.62845325,  1.93125694, -0.29817573]])"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "what happens here is that the boolean values are arranged across each\n",
    "length of values and the values where the True values are these\n",
    "values are returned, this is done from the x-axis\"\"\"\n",
    "rand_arr[name_arr == 'Bob']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.0916526 , -0.04189856],\n",
       "       [-0.18208768,  0.91992037],\n",
       "       [ 1.62845325,  1.93125694]])"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "The result of the above can also like an array be indexed\n",
    "for example, the comma seperated indexed value serves as the \n",
    "indexing slice\n",
    "This would return elements from positions 0 - 1\n",
    "in both x and y axis \n",
    "\"\"\"\n",
    "rand_arr[name_arr == 'Bob', :2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.04189856,  0.91992037,  1.93125694])"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rand_arr[name_arr == \"Bob\", 1]  #returns the second array of elements on the y-axis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NEGATING BOOLEAN CONDITIONS\n",
    "--------------\n",
    "TO NEGATE THE BOOLEAN CONDITION, WE USE != and ~(boolean condition) when using it as a slice directly.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True, False, False,  True,  True,  True])"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name_arr != 'Bob' #returns the negated form of the boolean array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.40271386,  0.43379107,  1.16571544],\n",
       "       [ 1.72086647, -0.73101699, -0.45257566],\n",
       "       [ 2.60302456,  0.34744254,  0.5996749 ],\n",
       "       [ 1.75175897,  0.66898376,  1.45171949]])"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "inorder to directly use negated/inverted boolean arrays directly as \n",
    "slices for another array, you do the following;\n",
    "\"\"\"\n",
    "\"\"\"\n",
    "notice the values retrieved earlier are completely different from these ones\n",
    "this is because the boolean conditions changed. Therefore, where there\n",
    "was a True value there is a false value and vice versa\n",
    "\"\"\"\n",
    "rand_arr[~(name_arr == \"Bob\")] #the ~ sign before the condition check in ()\n",
    "                         #automatically negates the boolean values to be used as slices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.40271386],\n",
       "       [1.72086647],\n",
       "       [2.60302456],\n",
       "       [1.75175897]])"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "the above can also be sliced like other arrays\n",
    "\"\"\"\n",
    "rand_arr[~(name_arr == \"Bob\"), :1]   #this returns all arrays in position 0\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "COMBINING MULTIPLE BOOLEAN CONDITIONS USING |(or) AND &(and)\n",
    "------------------------\n",
    "#### Note: the and/or boolean keywords are not used in numpy arrays but their symbols for example;\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False,  True,  True, False, False, False])"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(name_arr == \"Bob\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True, False, False, False, False, False])"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(name_arr == \"Foo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Combining conditions using |\n",
    "---------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True,  True, False, False, False])"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "here the two arrays gotten from each array check is compared\n",
    "against the other and a new array is generated in which its values\n",
    "are true where both elements are true and \n",
    "any element is true in that position of the arrays\n",
    "and false where both are false\"\"\"\n",
    "\n",
    "(name_arr == \"Bob\") | (name_arr == \"Foo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False,  True,  True,  True])"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "we can also slice and negate the array from the combined \n",
    "condition check as done before using (), ~ \n",
    "for example; in comparison with the above array,\n",
    "you would notice the array is inverted \"\"\"\n",
    "\n",
    "~((name_arr == \"Bob\") | (name_arr == \"Foo\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.72086647, -0.73101699, -0.45257566],\n",
       "       [ 2.60302456,  0.34744254,  0.5996749 ],\n",
       "       [ 1.75175897,  0.66898376,  1.45171949]])"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "we could also use this in slicing the random array generated earlier\n",
    "for example,\"\"\"\n",
    "\n",
    "rand_arr[~((name_arr == \"Bob\") | (name_arr == \"Foo\"))]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Combining conditions using &\n",
    "---------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False, False, False, False])"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "here the two arrays gotten from each array check is compared\n",
    "against the other and a new array is generated in which its values\n",
    "are only true where both elements are true, else it is false\n",
    "\"\"\"\n",
    "\n",
    "(name_arr == \"Bob\") & (name_arr == \"Foo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True,  True,  True,  True,  True])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#now let's invert this \n",
    "~((name_arr == \"Bob\") & (name_arr == \"Foo\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.72086647, -0.73101699, -0.45257566],\n",
       "       [ 2.60302456,  0.34744254,  0.5996749 ],\n",
       "       [ 1.75175897,  0.66898376,  1.45171949]])"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#let's use it as a slice to rand_arr\n",
    "rand_arr[~((name_arr == \"Bob\") | (name_arr == \"Foo\"))]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### *Note: the result gotten from using | and & can also be sliced like the other arrays indexed earlier*\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ALTERING SPECIFIC VALUES IN A NUMPY ARRAY\n",
    "--------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.0916526 , 3.        , 3.        ],\n",
       "       [1.40271386, 0.43379107, 1.16571544],\n",
       "       [3.        , 0.91992037, 3.        ],\n",
       "       [1.62845325, 1.93125694, 3.        ],\n",
       "       [1.72086647, 3.        , 3.        ],\n",
       "       [2.60302456, 0.34744254, 0.5996749 ],\n",
       "       [1.75175897, 0.66898376, 1.45171949]])"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "lets change all negative values in the rand_arr to 3\n",
    "to do this we would do the following\n",
    "\"\"\"\n",
    "\"\"\"\n",
    "so in a case where you don't want your initial array \n",
    "altered, first copy the array to a variable using .copy()\n",
    "then make your changes\n",
    "\"\"\"\n",
    "\n",
    "rand_arr[rand_arr < 0] = 3\n",
    "rand_arr   #notice that all negative values have been replaced by 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[8900., 8900., 8900.],\n",
       "       [8900., 8900., 8900.],\n",
       "       [8900., 8900., 8900.],\n",
       "       [8900., 8900., 8900.],\n",
       "       [8900., 8900., 8900.],\n",
       "       [8900., 8900., 8900.],\n",
       "       [8900., 8900., 8900.]])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "this can also be done to all positive values\n",
    "Also note that this alters the original rand_arr\n",
    "so in a case where you don't want your initial array \n",
    "altered, first copy the array to a variable using .copy()\n",
    "then make your changes\n",
    "\"\"\"\n",
    "\n",
    "rand_arr[rand_arr > 0] = 8900\n",
    "rand_arr  #all the values in the array got altered cause the initial\n",
    "          #changes made, replaced the negative values by 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4.        ,  4.        ,  4.        ],\n",
       "       [ 0.49911328,  1.24688141,  0.12797602],\n",
       "       [-0.05386412,  0.14824178,  0.03622516],\n",
       "       [ 4.        ,  4.        ,  4.        ],\n",
       "       [ 1.09003916, -0.49333916,  0.1953586 ],\n",
       "       [ 1.77377584, -0.34575555,  0.81595626],\n",
       "       [ 0.77435457, -1.19903317,  1.13743822],\n",
       "       [ 4.        ,  4.        ,  4.        ]])"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "We can also use boolean arrays to alter the values in another\n",
    "array as seen below;\n",
    "let's define an array of random numbers then use another array of\n",
    "character values with a boolean condition to index and change\n",
    "true values\n",
    "\"\"\"\n",
    "arandArr = np.random.randn(8,3)\n",
    "alphaNumArr = np.array(['Vier','Twee','Eend','Vier','Twee', 'Meisje','Drie','Vier'])\n",
    "\n",
    "arandArr[alphaNumArr == 'Vier'] = 4\n",
    "\n",
    "arandArr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "FANCY INDEXING\n",
    "----------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3., 3., 3., 3.],\n",
       "       [4., 4., 4., 4.],\n",
       "       [5., 5., 5., 5.],\n",
       "       [6., 6., 6., 6.],\n",
       "       [7., 7., 7., 7.],\n",
       "       [8., 8., 8., 8.],\n",
       "       [9., 9., 9., 9.]])"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "let's create an array of numbers\n",
    "\"\"\"\n",
    "numArr = np.zeros((7,4))\n",
    "for x in range(7):\n",
    "    numArr[x] = x+3\n",
    "numArr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6., 6., 6., 6.],\n",
       "       [8., 8., 8., 8.],\n",
       "       [9., 9., 9., 9.],\n",
       "       [3., 3., 3., 3.]])"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "To select a particular subset of data\n",
    "from the array\n",
    "\"\"\"\n",
    "\"\"\"\n",
    "that is, it enters the first array\n",
    "then it picks the array from the positions 3,5,6,0\n",
    "\"\"\"\n",
    "numArr[[3,5,6,0]] #this returns the arrays in positions 3,5,6\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[9., 9., 9., 9.],\n",
       "       [5., 5., 5., 5.],\n",
       "       [7., 7., 7., 7.]])"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numArr[[-1, -5, -3]] #the array can also be sliced using negative indexes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [ 5,  6,  7,  8,  9],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [15, 16, 17, 18, 19],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [25, 26, 27, 28, 29],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [35, 36, 37, 38, 39]])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Let's create an array of numbers\n",
    "then re-shape into multi-dimensional arrays\n",
    "\"\"\"\n",
    "numba = np.arange(40).reshape((8,5))\n",
    "numba"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([22,  2, 19])"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "we can slice the array using the following:\n",
    "it sorts the array into tuples like;\n",
    "the first array represents the columns,\n",
    "the second array represents the rows.\n",
    "red=(4,2),purple=(0,2),green=(3,4)\n",
    "\"\"\"\n",
    "numba[[4,0,3],[2,2,4]]"
   ]
  },
  {
   "attachments": {
    "vvv.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![vvv.png](attachment:vvv.png)\n",
    "\n",
    "Image explaining more about slicing the array above.\n",
    "------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 7, 16, 15])"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "just like the above let's redo this with\n",
    "different slice values\n",
    "\"\"\"\n",
    "numba[[1,3,3],[2,1,0]]\n",
    "#(1,2),(3,1),(3,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  8,  6,  7],\n",
       "       [20, 23, 21, 22],\n",
       "       [ 0,  3,  1,  2],\n",
       "       [10, 13, 11, 12]])"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "this takes each value and creates an array against the second array\n",
    "like (1)[0, 3, 1, 2], (4)[0, 3, 1, 2], (0)[0, 3, 1, 2] (2)[0, 3, 1, 2]\n",
    "and creates a multidimensional array\n",
    "\"\"\"\n",
    "\n",
    "numba[[1, 4, 0, 2]][:, [0, 3, 1, 2]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [ 5,  6,  7,  8,  9],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [15, 16, 17, 18, 19],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [25, 26, 27, 28, 29],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [35, 36, 37, 38, 39]])"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "notice that fancy indexing copies the data\n",
    "into a new array\n",
    "\"\"\"\n",
    "numba[[1, 4, 0, 2]][:, [0, 3, 1, 2]] = 7809800\n",
    "numba"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TRANSPOSING ARRAYS AND SWAPPING AXES\n",
    "----------------\n",
    "#### reshapes an array by interchanges the axes of an array and creates a new array, it does not copy the array. \n",
    "#### Example: a 3x4 array becomes a 4x3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11, 12, 13, 14, 15],\n",
       "       [16, 17, 18, 19, 20, 21, 22, 23],\n",
       "       [24, 25, 26, 27, 28, 29, 30, 31],\n",
       "       [32, 33, 34, 35, 36, 37, 38, 39],\n",
       "       [40, 41, 42, 43, 44, 45, 46, 47]])"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "lets creates a multi-dimensional array\n",
    "\"\"\"\n",
    "marr = np.arange(48).reshape(6, 8)\n",
    "marr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  8, 16, 24, 32, 40],\n",
       "       [ 1,  9, 17, 25, 33, 41],\n",
       "       [ 2, 10, 18, 26, 34, 42],\n",
       "       [ 3, 11, 19, 27, 35, 43],\n",
       "       [ 4, 12, 20, 28, 36, 44],\n",
       "       [ 5, 13, 21, 29, 37, 45],\n",
       "       [ 6, 14, 22, 30, 38, 46],\n",
       "       [ 7, 15, 23, 31, 39, 47]])"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "now let's create a transpose of this array\n",
    "using .T\n",
    "Notice that the axes have been swapped for each array\n",
    "\"\"\"\n",
    "marrTranspose = marr.T\n",
    "marrTranspose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.01071251,  1.77516685, -0.75750393],\n",
       "       [-0.43361015,  0.75780628, -0.2485985 ],\n",
       "       [-0.11824496,  2.15888942,  0.16001012],\n",
       "       [-0.08503624, -0.0516372 , -1.12711161],\n",
       "       [ 0.43769052, -0.33444752,  0.9101091 ]])"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "when performing matrix computations, using np.dot\n",
    "for example, computing the inner matrix product \n",
    "the transpose comes in matric\n",
    "lets see an example;\n",
    "let's create a new array of random numbers, get its transpose and\n",
    "use it as parameters for np.dot to get the inner matrix product\n",
    "\"\"\"\n",
    "\n",
    "arrNum = np.random.randn(5,3) #create a multi-dimensional array \n",
    "arrNum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.40091854, -0.70684725,  0.57495112],\n",
       "       [-0.70684725,  8.50081277, -1.43382405],\n",
       "       [ 0.57495112, -1.43382405,  2.75989581]])"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(arrNum.T, arrNum) #computation for the inner matrix product"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CREATING AND DERIVING THE TRANSPOSE OF HIGHER MULTIDIMENSIONAL ARRAYS\n",
    "----------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3],\n",
       "        [ 4,  5,  6,  7],\n",
       "        [ 8,  9, 10, 11]],\n",
       "\n",
       "       [[12, 13, 14, 15],\n",
       "        [16, 17, 18, 19],\n",
       "        [20, 21, 22, 23]],\n",
       "\n",
       "       [[24, 25, 26, 27],\n",
       "        [28, 29, 30, 31],\n",
       "        [32, 33, 34, 35]]])"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "this creates 3 multi-dimensional arrays with \n",
    "3x4 dimensions\n",
    "\"\"\"\n",
    "highArr = np.arange(36).reshape((3,3,4))\n",
    "highArr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3],\n",
       "        [ 4,  5,  6,  7],\n",
       "        [ 8,  9, 10, 11]],\n",
       "\n",
       "       [[12, 13, 14, 15],\n",
       "        [16, 17, 18, 19],\n",
       "        [20, 21, 22, 23]],\n",
       "\n",
       "       [[24, 25, 26, 27],\n",
       "        [28, 29, 30, 31],\n",
       "        [32, 33, 34, 35]]])"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "to derive the transpose of this array created above, the transpose\n",
    "requires a tuple of axis values.\n",
    "the values to be used must be values within the range of one lesser\n",
    "than the axes value of the column.\n",
    "It does not taken in repetitive values like (0,0,3) is wrong\n",
    "for example;\n",
    "\"\"\"\n",
    "\n",
    "highArr.transpose((0,1,2))  #this returns the same matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  4,  8],\n",
       "        [ 1,  5,  9],\n",
       "        [ 2,  6, 10],\n",
       "        [ 3,  7, 11]],\n",
       "\n",
       "       [[12, 16, 20],\n",
       "        [13, 17, 21],\n",
       "        [14, 18, 22],\n",
       "        [15, 19, 23]],\n",
       "\n",
       "       [[24, 28, 32],\n",
       "        [25, 29, 33],\n",
       "        [26, 30, 34],\n",
       "        [27, 31, 35]]])"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "this returns a matrix of values derived from picking\n",
    "values from columns and interchanging them with the row values\n",
    "for each multi-dimensional array\n",
    "\"\"\"\n",
    "highArr.transpose((0,2,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3],\n",
       "        [12, 13, 14, 15],\n",
       "        [24, 25, 26, 27]],\n",
       "\n",
       "       [[ 4,  5,  6,  7],\n",
       "        [16, 17, 18, 19],\n",
       "        [28, 29, 30, 31]],\n",
       "\n",
       "       [[ 8,  9, 10, 11],\n",
       "        [20, 21, 22, 23],\n",
       "        [32, 33, 34, 35]]])"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "this returns a matrix of values derived from picking\n",
    "values from the first rows of each multi-dimensional values\n",
    "and creates a new array of it and also does the same for the following\n",
    "row values.\n",
    "\"\"\"\n",
    "highArr.transpose((1,0,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SWAPAXES\n",
    "-----\n",
    "### Ndarray has the method *swapaxes* , which takes a pair of axis numbers and switches the indicated axes to rearrange the data. It also returns a view on the data without making a copy.\n",
    "for example;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3],\n",
       "        [ 4,  5,  6,  7],\n",
       "        [ 8,  9, 10, 11]],\n",
       "\n",
       "       [[12, 13, 14, 15],\n",
       "        [16, 17, 18, 19],\n",
       "        [20, 21, 22, 23]],\n",
       "\n",
       "       [[24, 25, 26, 27],\n",
       "        [28, 29, 30, 31],\n",
       "        [32, 33, 34, 35]]])"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "highArr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  4,  8],\n",
       "        [ 1,  5,  9],\n",
       "        [ 2,  6, 10],\n",
       "        [ 3,  7, 11]],\n",
       "\n",
       "       [[12, 16, 20],\n",
       "        [13, 17, 21],\n",
       "        [14, 18, 22],\n",
       "        [15, 19, 23]],\n",
       "\n",
       "       [[24, 28, 32],\n",
       "        [25, 29, 33],\n",
       "        [26, 30, 34],\n",
       "        [27, 31, 35]]])"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "highArr.swapaxes(2,1) #interchanges the position of the values on their initial axes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "UNIVERSAL FUNCTIONS(ufunc)\n",
    "--------\n",
    "are functions that perform operations on individual elements in an array and return a new array of the result from the operation, which is mostly a single array.\n",
    "They are classified into the following;\n",
    "- Unary Ufunc: are ufuncs that take in one array and performs operations then returns a new array of its resultant values.\n",
    "- Binary Ufunc: are ufuncs that take in two arrays and perform operations then return a single array.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "UNARY UNIVERSAL  FUNCTIONS\n",
    "-------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 1.        , 1.41421356, 1.73205081, 2.        ,\n",
       "       2.23606798, 2.44948974, 2.64575131, 2.82842712, 3.        ,\n",
       "       3.16227766, 3.31662479, 3.46410162, 3.60555128, 3.74165739,\n",
       "       3.87298335, 4.        ])"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Let's define a new array\n",
    "\"\"\"\n",
    "newArr = np.arange(17)\n",
    "np.sqrt(newArr)    #gets the sqrt of values in an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.00000000e+00, 2.71828183e+00, 7.38905610e+00, 2.00855369e+01,\n",
       "       5.45981500e+01, 1.48413159e+02, 4.03428793e+02, 1.09663316e+03,\n",
       "       2.98095799e+03, 8.10308393e+03, 2.20264658e+04, 5.98741417e+04,\n",
       "       1.62754791e+05, 4.42413392e+05, 1.20260428e+06, 3.26901737e+06,\n",
       "       8.88611052e+06])"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(newArr)   #gets the exp of values in an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12.,\n",
       "       13., 14., 15., 16.])"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.square(np.sqrt(newArr))  #returns the square of elements in an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.,  1., -1.,  1., -1.,  1., -1.,  1.,  1.])"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sign(np.random.randn(9))  #returns the sign of each element \n",
    "                             #1 (positive), 0 (zero), or –1 (negative)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2.23606798, 2.64575131, 3.        , 1.73205081, 2.44948974,\n",
       "       2.82842712])"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(np.array([5,7,9,3,6,8]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3., 3., 3., 2., 3., 3.])"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "returns the smallest integer > or = the number\n",
    "\"\"\"\n",
    "np.ceil(np.sqrt(np.array([5,7,9,3,6,8])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2., 2., 3., 1., 2., 2., 5.])"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.floor(np.sqrt(np.array([5,7,9,3,6,8,34]))) #returns the integer part of a floating point number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Binary Ufunc\n",
    "-------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.15302519, -0.58998211,  0.477254  , -0.73175764,  0.45316217,\n",
       "        1.39497762,  0.85909883, -1.01967759, -0.79898593])"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "\"\"\"\n",
    "the size of the two arrays to be compared must be same\n",
    "else a valueError would be thrown\n",
    "\"\"\"\n",
    "x = np.random.randn(9)\n",
    "y = np.random.randn(9)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.1167239 ,  0.54547968, -0.27344299,  1.53655756,  0.15217984,\n",
       "        0.4685714 ,  0.57018843, -0.17001839,  0.37206014])"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.1167239 ,  0.54547968,  0.477254  ,  1.53655756,  0.45316217,\n",
       "        1.39497762,  0.85909883, -0.17001839,  0.37206014])"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "this compares elements in each array against it's corresponding\n",
    "element in the other array and returns a new single array of \n",
    "the max values\n",
    "\"\"\"\n",
    "np.maximum(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.26974909, -0.04450243,  0.20381101,  0.80479992,  0.605342  ,\n",
       "        1.86354902,  1.42928727, -1.18969597, -0.42692579])"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.add(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.31100134, -1.08158403, -1.74535103, -0.47623185,  2.9778069 ,\n",
       "        2.97708658,  1.50669284,  5.99745485, -2.14746446])"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.divide(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.03630129, -1.13546178,  0.75069698, -2.2683152 ,  0.30098233,\n",
       "        0.92640622,  0.2889104 , -0.8496592 , -1.17104607])"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.subtract(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.0178617 , -0.32182325, -0.13050176, -1.12438774,  0.06896214,\n",
       "        0.65364662,  0.48984822,  0.17336394, -0.29727082])"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.multiply(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ufunc can also return multiple arrays, for example, when using the numpy .modf method, it returns both the fractional and remainder part of a floating point array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.0178617 , -0.32182325, -0.13050176, -0.12438774,  0.06896214,\n",
       "        0.65364662,  0.48984822,  0.17336394, -0.29727082])"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arrVal = np.multiply(x,y)\n",
    "remainder,whole = np.modf(arrVal)\n",
    "remainder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0., -0., -0., -1.,  0.,  0.,  0.,  0., -0.])"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "whole"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-182-a86874f0dcf5>:8: RuntimeWarning: invalid value encountered in sqrt\n",
      "  np.sqrt(x, x)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([       nan,        nan, 0.69083572,        nan, 0.67317321,\n",
       "       1.18109171, 0.92687585,        nan,        nan])"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Ufuncs accept an optional out argument that allows them to operate in-place on\n",
    "arrays.\n",
    "Noter the arrays entered must be of the same kind else an error would \n",
    "be thrown\n",
    "\"\"\"\n",
    "\n",
    "np.sqrt(x, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5, 14, 23, 32])"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "points = np.arange(5, 35, 9)   #creates a range of numbers between 5 and -5 spaced with 0.68\n",
    "points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5, 14, 23, 32],\n",
       "       [ 5, 14, 23, 32],\n",
       "       [ 5, 14, 23, 32],\n",
       "       [ 5, 14, 23, 32]])"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "creates a multi-dimensional array of the same length of the\n",
    "initial array, organizes the elements in the array against the axis\n",
    "\"\"\"\n",
    "xs,ys = np.meshgrid(points, points)     \n",
    "xs          "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  5,  5,  5],\n",
       "       [14, 14, 14, 14],\n",
       "       [23, 23, 23, 23],\n",
       "       [32, 32, 32, 32]])"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10, 19, 28, 37],\n",
       "       [19, 28, 37, 46],\n",
       "       [28, 37, 46, 55],\n",
       "       [37, 46, 55, 64]])"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xs + ys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 7.07106781, 14.86606875, 23.53720459, 32.38826948],\n",
       "       [14.86606875, 19.79898987, 26.92582404, 34.92849839],\n",
       "       [23.53720459, 26.92582404, 32.52691193, 39.40812099],\n",
       "       [32.38826948, 34.92849839, 39.40812099, 45.254834  ]])"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = np.sqrt(xs ** 2 + ys ** 2)\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Expressing Conditional Logic as Array Operations\n",
    "----------------\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3.4, 4.6, 4.0, 5.8, 9.9]"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "this returns a value from the warr when the value in cond is\n",
    "True, else value from yarr\"\"\"\n",
    "warr = np.array([3.4, 3.3, 4.0, 5.8, 7.5])\n",
    "yarr = np.array([6.5, 4.6, 5.5, 6.0, 9.9])\n",
    "cond = np.array([True, False, True, True, False])\n",
    "resut = [(x if c else y) for x, y, c in zip(warr, yarr, cond)]\n",
    "resut"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.4, 4.6, 4. , 5.8, 9.9])"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "The above can be achieved simply using np.where\n",
    "\"\"\"\n",
    "resut = np.where(cond, warr, yarr)\n",
    "resut"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4.39096128, -1.33903468,  0.35002582, -1.54420141,  0.2567759 ],\n",
       "       [-0.72555777, -0.05626163,  0.56771219, -0.68650939,  0.51732535],\n",
       "       [ 0.01790029,  0.8289801 ,  1.46919441, -1.02236035,  0.12237406],\n",
       "       [-0.34539493, -0.94784684,  1.67464821, -1.6245256 ,  0.7046263 ],\n",
       "       [-0.04121273,  1.68960426, -0.52867567, -0.44455024, -0.12117   ]])"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "We change the positive values and negative values in an array\n",
    "by simply using np.where. np.where accepts arrays or non-arrays as its'\n",
    "second and third values.\n",
    "Let's create an array of random values and replace all negative\n",
    "values 8 and the positive values with 5.\n",
    "\"\"\"\n",
    "\n",
    "randomArr = np.random.randn(5,5)\n",
    "randomArr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 8, 5, 8, 5],\n",
       "       [8, 8, 5, 8, 5],\n",
       "       [5, 5, 5, 8, 5],\n",
       "       [8, 8, 5, 8, 5],\n",
       "       [8, 5, 8, 8, 8]])"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"this checks for values > 0 and replaces them to 5\n",
    "else it replaces such value with 8\n",
    "\"\"\"\n",
    "np.where(randomArr > 0, 5,8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4.39096128, 6.        , 0.35002582, 6.        , 0.2567759 ],\n",
       "       [6.        , 6.        , 0.56771219, 6.        , 0.51732535],\n",
       "       [0.01790029, 0.8289801 , 1.46919441, 6.        , 0.12237406],\n",
       "       [6.        , 6.        , 1.67464821, 6.        , 0.7046263 ],\n",
       "       [6.        , 1.68960426, 6.        , 6.        , 6.        ]])"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"we can also replace only the negative values by doing\n",
    "as follows;\n",
    "Notice the change in the boolean operator.\n",
    "Also the 3rd value is an array, this causes the array value to be\n",
    "returned where the element is > 0\n",
    "\"\"\"\n",
    "np.where(randomArr < 0, 6, randomArr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "AGGREGATIONS\n",
    "-------\n",
    "#### are mathematical functions that compute statistics about an entire array or about the data along an axis are accessible as methods of the array class like sum, mean and std."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.98099817,  0.76469481, -0.53343891,  1.37113694],\n",
       "       [-1.21309437,  0.63875354, -0.12242404, -0.39740518],\n",
       "       [-0.12967748,  0.48387414, -1.33651354, -0.13433715],\n",
       "       [-0.93761995, -1.48257636,  0.35399552, -0.2402182 ],\n",
       "       [-0.66251316, -1.64999333,  1.57098628, -0.69282818],\n",
       "       [ 1.43617686,  0.78104832, -0.41034964, -0.21524969]])"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aggArr = np.random.randn(6,4)\n",
    "aggArr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.03235727560481796"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aggArr.mean()\n",
    "#or\n",
    "np.mean(aggArr)   #returns the mean of all values in the multi-dimensional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.89584775, -0.27354251, -0.27916351, -0.57660475, -0.3585871 ,\n",
       "        0.39790646])"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "the mean and sum of the rows and columns\n",
    "by passing in axis = 0 for computing across the rows and \n",
    "axis = 1 for computing across the columns resulting in a \n",
    "a one-dimensional array of elements. \n",
    "\"\"\"\n",
    "\n",
    "aggArr.mean(axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16])"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    ".cumsum performs the operations of the fibonacci series\n",
    "and returns an array of the values. For example;\n",
    "\"\"\"\n",
    "\n",
    "fibArr = np.arange(17)\n",
    "fibArr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0,   1,   3,   6,  10,  15,  21,  28,  36,  45,  55,  66,  78,\n",
       "        91, 105, 120, 136])"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibArr.cumsum()  #performs the fibonnaci operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" \n",
    "for multi-dimensional arrays, the axis to perform the operation \n",
    "can be passed as an argument to the cumsum method,\n",
    "like .cumsum(axis = 0)\n",
    "\"\"\"\n",
    "\n",
    "miArr = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [6, 7, 8]])"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miArr.cumsum(axis=0)  #performs operations along the columns\n",
    "miArr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2],\n",
       "       [ 0,  4, 10],\n",
       "       [ 0, 28, 80]])"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miArr.cumprod(axis=0)  #returns the fibo prod. on the columnsb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0])"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miArr.argmin(axis=1) #indices of minimum and maximum elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "METHODS FOR BOOLEAN ARRAYS\n",
    "-----------\n",
    "some boolean array methods include the following:\n",
    "- .sum(): returns the total number of a check value in an array\n",
    "- .any(): checks if any True values exists in an array, and returns True if any exists.\n",
    "- .all(): checks if all the values in an array are True, and returns either True or false."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.47938005,  1.41754545, -1.011917  ],\n",
       "       [-0.69516123,  0.378273  , -0.38225419],\n",
       "       [ 1.08507796,  0.5721494 , -0.19108405]])"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "let's create a random array of values and calculate\n",
    "the total number of negative number in the array\n",
    "\"\"\"\n",
    "somArr = np.random.randn(3,3)\n",
    "somArr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(somArr < 0).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False, False,  True,  True,  True])"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "lets specify a boolean array of random bool values\n",
    "then check use the any and all to check against it\n",
    "\"\"\"\n",
    "boolArr = np.array([True, False, False, True, True, True])\n",
    "boolArr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "boolArr.any()   #checks for existence of True values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "boolArr.all()    #checks if all values are True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.56672017, -0.5125413 ,  1.14856768],\n",
       "       [ 1.24023883, -0.51558193, -0.51843521],\n",
       "       [ 0.72426321,  0.062162  , -0.72446492],\n",
       "       [-0.96296775, -0.94716709, -0.30690826],\n",
       "       [ 0.06081638, -0.80457062,  1.72085636]])"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"numpy arrays can also be sorted using the .sort() method\n",
    "to sort multi-dimensional arrays the axis args can also\n",
    "be passed\n",
    "np.sort returns a sorted copy of an array instead of modifying\n",
    "the array in-place\n",
    "\"\"\"\n",
    "sort_Arr = np.random.randn(5,3)\n",
    "sort_Arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.96296775, -0.94716709, -0.72446492],\n",
       "       [ 0.06081638, -0.80457062, -0.51843521],\n",
       "       [ 0.56672017, -0.51558193, -0.30690826],\n",
       "       [ 0.72426321, -0.5125413 ,  1.14856768],\n",
       "       [ 1.24023883,  0.062162  ,  1.72085636]])"
      ]
     },
     "execution_count": 228,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sort_Arr.sort(0)   #sorts along the columns\n",
    "sort_Arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.87416408, -0.39286307, -0.05175211,  1.00130016])"
      ]
     },
     "execution_count": 241,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oneDimArr= np.random.randn(4)\n",
    "oneDimArr.sort()\n",
    "oneDimArr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.43166416, -0.02424425,  0.02120963,  0.8213947 ,  1.0955762 ,\n",
       "        1.11657552,  1.30050728,  1.46684367,  1.57205496,  1.67834364])"
      ]
     },
     "execution_count": 262,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "sorting of arrays can be used to get quantiles of an array\n",
    "let's say we want to get the 7th quantile of sortedArr\n",
    "we can simply do the following using slicing on the sorted\n",
    "to get the 7th quantile\n",
    "\"\"\"\n",
    "sortedArr = np.random.randn(10)\n",
    "sortedArr.sort()\n",
    "sortedArr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4668436722313778"
      ]
     },
     "execution_count": 264,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sortedArr[int(0.7 * len(sortedArr))] #returns the 7th element in the sorted array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unique and Other Set Logic\n",
    "--------\n",
    "NumPy has some basic set operations for one-dimensional ndarrays like np.unique, np.in1d."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Drag', 'Goat', 'Gold'], dtype='<U4')"
      ]
     },
     "execution_count": 265,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "This sorts an array and returns unique elements in the array\n",
    "just like the python, code seen below on the next block would do, and\n",
    "it returns the dtype of the array\n",
    "\"\"\"\n",
    "char = np.array(['Gold', 'Drag', 'Goat', 'Drag', 'Gold','Goat'])\n",
    "np.unique(char) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Drag', 'Goat', 'Gold']"
      ]
     },
     "execution_count": 266,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(set(char))  #the set() returns unique elements then sorted() sorts in place the values returned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False, False, False,  True,  True, False,\n",
       "       False,  True, False, False])"
      ]
     },
     "execution_count": 267,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vals = np.array([4,5,6,7,0,4,3,3,7,6,9,7,0])\n",
    "np.in1d(vals,[3,9]) #this checks the val arr for occurrences of 3 or 9 and returns true if found else false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 16, 33, 44, 67, 90])"
      ]
     },
     "execution_count": 271,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#### other array set operations\n",
    "eenArr = np.arange(8)\n",
    "tweeArr = np.array([3,7,67,4,44,0,4,8,9,16,33,90])\n",
    "np.union1d(eenArr,tweeArr)  #returns a new array containing sorted union elements of both arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 3, 4, 7])"
      ]
     },
     "execution_count": 273,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.intersect1d(eenArr, tweeArr) #returns a sorted array of similar elements in both arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  5,  6,  8,  9, 16, 33, 44, 67, 90])"
      ]
     },
     "execution_count": 275,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.setxor1d(eenArr, tweeArr)  #removes all similar elements and sorts the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 5, 6])"
      ]
     },
     "execution_count": 277,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.setdiff1d(eenArr, tweeArr) #returns a sorted array of the difference in elements of both arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "File input and output with arrays\n",
    "-----------\n",
    "#### Numpy can save and load data to and from disk using its np.load and np.save functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"to save the content of saveArr to the arrFile,\n",
    "you pass in the filename and the content/file to be saved as args\n",
    "to np.save, np.save takes in these  2 args.\n",
    "this creates an arrFile with the .npy extension and\n",
    "adds the content of saveArr to it.\n",
    "Once this is done check your current working directory for this file\n",
    "\"\"\"\n",
    "saveArr = np.arange(35)\n",
    "np.save('arrFile',saveArr) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "       17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n",
       "       34])"
      ]
     },
     "execution_count": 279,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "to load and view the contents of this file \n",
    "we use np.load() passing in file name to open as args\n",
    "in this case, \"arrFile.npy\"\n",
    "\"\"\"\n",
    "np.load('arrFile.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "multiple arrays can also be saved in an\n",
    "uncompressed archive using np.savez which saves arrays as dict-like objects,\n",
    "Here the arrays are passed in as args after the filename, and\n",
    "assigning the arr to value which when saved becomes the key, while\n",
    "the array becomes the value, just like with dictionaries\n",
    "current working directory.\n",
    "let's save the last 4 arrays we created earlier\n",
    "\"\"\"\n",
    "np.savez('largeArrFile',a=saveArr, b=eenArr, c=tweeArr, d=vals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Now let's load this file and view its' content.\n",
    "Note that files with .npz extension when loaded\n",
    "return a dict-like object.\n",
    "so we would load it into a variable\n",
    "\"\"\"\n",
    "var = np.load(\"largeArrFile.npz\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  7, 67,  4, 44,  0,  4,  8,  9, 16, 33, 90])"
      ]
     },
     "execution_count": 287,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "now get the actual values of the arrays, like with dict\n",
    "we would use the keys we passed in initially.\n",
    "let's view the contents in c.\n",
    "\"\"\"\n",
    "var['c']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a',\n",
       "  array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "         17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n",
       "         34])),\n",
       " ('b', array([0, 1, 2, 3, 4, 5, 6, 7])),\n",
       " ('c', array([ 3,  7, 67,  4, 44,  0,  4,  8,  9, 16, 33, 90])),\n",
       " ('d', array([4, 5, 6, 7, 0, 4, 3, 3, 7, 6, 9, 7, 0]))]"
      ]
     },
     "execution_count": 291,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "all the contents of this file can be viewed just like with the\n",
    "python dictionaries with .items() method\"\"\"\n",
    "[(k,v) for k,v in var.items()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "multiple arrays can also be saved in a compressed format using\n",
    "np.savez_compressed() function.\n",
    "for example, let's resave he last 4 arrays.\n",
    "check your current working directory and compare their sizes\n",
    "Mine is;\n",
    "largeArrFile.npz = 1.5kilobytes\n",
    "compressedFile.npz = 876bytes\n",
    "\"\"\"\n",
    "np.savez_compressed('compressedFile',a=saveArr, b=eenArr, c=tweeArr, d=vals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LINEAR ALGEBRA\n",
    "---\n"
   ]
  }
 ],
 "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}