{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a quick review of some basic python features that you will need to do your assignments. \n",
    "Of course, this is far from being exhaustive. We have put together some code snippets below. \n",
    "You should be able to run any piece on its own in python version  3.x - just place the cursor in \n",
    "the code cell you want to execute, then click on 'Cell/Run' or click on the \"play\" button.\n",
    "\n",
    "Python is indentation-sensitive by design – so, please follow the left-indentation that I have used. Otherwise, \n",
    "you will receive an 'IndentationError'. It doesn’t have to be the exact same amount of indentation, however. \n",
    "For example, if you see a tab, it means that there needs to be some left-indentation there; \n",
    "it could be just a single space (I just prefer tabs only for clarity). But if you don’t see any indentation, \n",
    "then there shouldn’t be any.\n",
    "\n",
    "Any line that starts with a '#' is a comment, that is Python does not execute it.\n",
    "\n",
    "Official Python documentation - http://python.org/doc/\n",
    "\n",
    "A popular book “A byte of python\" - http://www.swaroopch.com/notes/Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Review"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "#This command opens a python terminal that has gives you access to this notebook's namespace.\n",
    "#that is, variables you define within this notebook are only accessible through the special console \n",
    "#invoked by the command below. The default Python kernel or console you see below does not provide \n",
    "#you that acess. NOTE that this is a special iPython \"magic\" command, not a regular Python command.\n",
    "\n",
    "%qtconsole"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(1)** At the beginning of a program you might want to specify that you want to use certain “packages” in order to \n",
    "use their special features that python doesn’t automatically provide. Some packages like ‘math’ and ‘array’ come with python. Others like ‘pygame’ and ‘numpy’ need to be installed. To tell the program that you want to use a package, say, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math as m  \n",
    "#'math' is the name of the package, 'm' is its alias that is easier to use\n",
    "\n",
    "import random as rnd\n",
    "#‘Random’ package: Use this package to pull random numbers from a given range."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(2)** Each package has its features implemented in the form of “modules” or \"functions\" to which \n",
    "you can pass parameters and get results in return. You can invoke the modules with the \n",
    "name of the package (or its alias) followed by a ‘.’ that is then followed by the name of the module (modules don’t have aliases). For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n"
     ]
    }
   ],
   "source": [
    "print((m.sqrt(16)))    #'sqrt' is the square root module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1.0\n"
     ]
    }
   ],
   "source": [
    "print((m.cos(m.pi)))  #besides functions packages also have constants (e.g., 'pi') defined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28\n"
     ]
    }
   ],
   "source": [
    "print((rnd.randint(0,100)))  #randomly pull a number from the range 0 through 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(3) Conditional logic** statements: Note how the else-if is implemented in python – it is ‘elif’. \n",
    "Also, notice the colon at the end of the conditions which is part of the syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is < 1\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "\n",
    "if x == 1: print(\"x is 1\")\n",
    "elif x > 1:\n",
    "\tprint(\"x is > 1\")\n",
    "else:\n",
    "\tprint(\"x is < 1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(4) Loops**: Again note the colon at the end of the loop statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "canopy_exercise": {
     "cell_type": "<None>"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "x=0\n",
    "\n",
    "while x < 10:\n",
    "\tx += 1  #the '+= ' which is typical in C also works in python\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-35\n"
     ]
    }
   ],
   "source": [
    "for i in range(0,10):  #range(0,10) returns a list of values from 0 through 9\n",
    "\tx -= i\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NOTE: All datatypes in Python have their indices starting from 0 as opposed to 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(5) Lists**: A list is an indexed container where you can store a variety of elements like integers, decimals, and strings in the same list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 'mad', 3.2, 'more']\n"
     ]
    }
   ],
   "source": [
    "L = [10, 'mad',3.2]  #list containing 3 different types of elements. Note the square brackets.\n",
    "\n",
    "L.append('more')  #append a string to the end of the list\n",
    "\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "print((L[0]))  #access an element of the list; indices start with 0, and not 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print((L.index('mad')))  #retrieves the 'index' of 'mad' in L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 3.2, 'more']\n"
     ]
    }
   ],
   "source": [
    "del L[1]  #delete the element stored at index 1\n",
    "\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n"
     ]
    }
   ],
   "source": [
    "#A standard way of generating a list of numbers (this one generates a list from 0 through 19).\n",
    "Lst = list(range(0,20))  \n",
    "\n",
    "print(Lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "([3, 4, 5, 6, 7, 8, 9], [15, 16, 17, 18])\n"
     ]
    }
   ],
   "source": [
    "print((Lst[3:10], Lst[15:19]))  #indexing parts of a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(5a) List generators**: this is a very useful functionality that you will often need."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]\n"
     ]
    }
   ],
   "source": [
    "L1 = list(n*2 for n in range(10))\n",
    "\n",
    "print(L1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]\n"
     ]
    }
   ],
   "source": [
    "#Equivalently,\n",
    "L1 = [n*2 for n in range(10)]\n",
    "\n",
    "print(L1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "#Generates a list of indices for items in another list\n",
    "L2 = [L1.index(item) for item in L1]\n",
    "\n",
    "print(L2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'a'), (1, 'b'), (2, 'c')]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#You can also generate a list of tuples in the following way using the function \"enumerate\":\n",
    "list(enumerate(['a','b','c']))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 3), (3, 4), (3, 5)]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Another way to generate a list of tuples is by making all possible combinations of items from a set of lists:\n",
    "list((x,y) for x in range(1,4) for y in range(3,6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(6) Tuples**: A tuple is very similar to list, in that it is also an indexed container used to store \n",
    "a variety of elements, but it is treated as an immutable data-type. You can have a list of tuples, \n",
    "for example, but you can’t append to a tuple after it is defined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2.5, 3.4)\n"
     ]
    }
   ],
   "source": [
    "T1 = (2.5, 3.4)  #Note the parantheses (square brackets for a list)\n",
    "\n",
    "print(T1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(2.5, 3.4)]\n"
     ]
    }
   ],
   "source": [
    "L = [] #To declare an empty list, you can also say: L = list()\n",
    "\n",
    "L.append(T1)  #appends a tuple to a list; note that there is no \"append\" available for a tuple\n",
    "\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2.5, 3.4)\n"
     ]
    }
   ],
   "source": [
    "print(L[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((12, 14), 1.5, (12, 13, 54))\n"
     ]
    }
   ],
   "source": [
    "T2 = ((12,14),1.5,(12,13,54))  #tuple within a tuple; 2-D coordinates and velocity, for example\n",
    "\n",
    "print(T2)  #accessing the contents of a tuple is the same as for a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(7) Arrays**: A popular package for using arrays is “numpy”. \n",
    "A nice tutorial is here - http://www.scipy.org/Tentative_NumPy_Tutorial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 30  23 100]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "x = np.array([30,23,100])  #you don’t have to mention the datatype (e.g., integer)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n"
     ]
    }
   ],
   "source": [
    "print(x[1])  #the second element of x: this is how you index an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 90  69 300]\n"
     ]
    }
   ],
   "source": [
    "y = x * 3  #multiplication of the entire array\n",
    "\n",
    "print(y)  #all elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([2], dtype=int64),)\n"
     ]
    }
   ],
   "source": [
    "#retrieve the index of an element in array; notice that the result is a tuple of arrays\n",
    "print(np.where(x == 100))  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "ind = np.where(x == 100) \n",
    "\n",
    "print(ind[0][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
      " 0. 0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "z = np.zeros(100)  #create an array of length 100 and store 0’s in it\n",
    "\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "   **(7a)** You can also use numpy to perform numerical calculations like logarithm, exponentiation etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "print(np.log2(2))  #base-2 logarithm of a single number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.         5.08746284 8.83289001]\n"
     ]
    }
   ],
   "source": [
    "print(np.log2([2,34,456]))  #compute the log of an array of numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "158\n"
     ]
    }
   ],
   "source": [
    "print(np.sum([1,59,98]))  #arithmetic sum of an array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(8) Matrices**: Generally, matrices are two-dimensional arrays. \n",
    "You can also think of a matrix as an array of arrays. Use numpy to define them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[11 32]\n",
      " [ 3 94]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "m = np.matrix([[11,32], [3,94]])  #pass a list of equally-sized lists to define a matrix\n",
    "\n",
    "print(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32\n"
     ]
    }
   ],
   "source": [
    "print(m[0,1])  #retrieves the element in the 0th row and 1st column of the matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(9) Dictionary**: It is defined as a set of \"keys\" and their corresponding \"values\". \n",
    "Given a key, you can retrieve its value from a dictionary. Dictionaries are convenient in \n",
    "defining relationships between entities, for example between alphabetic letters and numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "Char_to_Num = { 'A' : 10, 'B' : 36, 'C' : 21}  #note the use of curly braces\n",
    "#the 'key' is defined on the left of the colon, and its 'value' on the right\n",
    "\n",
    "print(Char_to_Num['A'])  #retrieves the value of the key 'A'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'B', 'C']\n"
     ]
    }
   ],
   "source": [
    "print(list(Char_to_Num.keys()))  #retrieves keys only, and returns them in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 36, 21]\n"
     ]
    }
   ],
   "source": [
    "print(list(Char_to_Num.values()))  #retrieves values only, and returns them in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C\n"
     ]
    }
   ],
   "source": [
    "print(list(Char_to_Num.keys())[list(Char_to_Num.values()).index(21)])  #retrieve the key for a value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(10) Strings**: They can be considered as arrays and indexed as you index an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y\n"
     ]
    }
   ],
   "source": [
    "s = \"python is\"\n",
    "\n",
    "print(s[1])  #the second character of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python is not a snake\n"
     ]
    }
   ],
   "source": [
    "s = s + \" not a snake\"  #the '+' concatenates the two strings\n",
    "\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "print(s.index('not'))  #index strings just as you index lists and tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(s.index('n'))  #retrieves the index of the first occurrence of 'n'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a,b,c'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#A clever way of generating a string with characters separated by commas (notice that 'join' is not \n",
    "#a standalone command -- it is a function defined for string objects; in this example):\n",
    "','.join(['a','b','c'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['s', 't', 'r', 'i', 'n', 'g']"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#You can make a list out of the characters of a string\n",
    "list(\"string\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(11) ASCII values**: Every keyboard character has a numerical ASCII value associated with it. \n",
    "Sometimes it is useful to have access to it, as it may be easier to deal with those numbers, \n",
    "rather than the original characters, in your program. Aside: 'ord' is short for ordinal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "70\n"
     ]
    }
   ],
   "source": [
    "print(ord('F'))  #the ASCII value of upper case F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L\n"
     ]
    }
   ],
   "source": [
    "print(chr(76))  #the character whose ASCII value is 76"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s\n"
     ]
    }
   ],
   "source": [
    "print(chr(ord('s')))  #returns the lower case 's '"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(12) Files**: Reading and writing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "# First set the working directory, where you want to read and write files\n",
    "import os\n",
    "\n",
    "# print(os.getcwd())  #retrieves current working directory\n",
    "\n",
    "# Switch to a different working directory, if you want to access files from there\n",
    "# os.chdir('/Users/smanicka/Documents/My IU/Spring 2015/Teaching I485/Lab 0')\n",
    "\n",
    "# Now move on to file operations\n",
    "f = open(\"text.txt\",\"r\")  #open file for reading; MAKE SURE THAT THIS FILE EXISTS\n",
    "\n",
    "lines = f.readlines()  #stores each line of the text in 'lines'\n",
    "\n",
    "print(len(lines))  #number of lines in this file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ipsum faucibus vitae aliquet nec ullamcorper sit. Tellus molestie nunc non blandit massa. Pretium aenean pharetra magna ac placerat. A erat nam at lectus urna duis convallis. Phasellus egestas tellus rutrum tellus. Sed sed risus pretium quam vulputate. Consequat mauris nunc congue nisi vitae suscipit tellus mauris. Luctus venenatis lectus magna fringilla urna porttitor. Praesent semper feugiat nibh sed pulvinar proin gravida. Purus viverra accumsan in nisl nisi scelerisque eu. Sit amet risus nullam eget felis eget nunc.a stringa string\n"
     ]
    }
   ],
   "source": [
    "print(lines[8])  #retrieves the 8th line, assuming there are that many lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f\n"
     ]
    }
   ],
   "source": [
    "print(lines[8][6])  #retrieves the 6th character of the 8th line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'M'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#If you want to do a fresh read, you should open the file again!\n",
    "f = open(\"text.txt\",\"r\")\n",
    "\n",
    "chars = f.read()  #stores all characters of the text, not single lines, in 'chars'\n",
    "\n",
    "chars[124]  #retrieves the 124th character of the text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open(\"text.txt\",\"a\")  #open file for writing; append to existing contents\n",
    "\n",
    "s = 'a string'\n",
    "\n",
    "f.write(s)\n",
    "\n",
    "f.close()  #this is required after a write, else you won’t see the new contents"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(13) Defining a function**: The following should be self-explanatory. Again, please pay \n",
    "attention to the indentation for the statement that follow after the first ‘def’ statement. \n",
    "To run the following code, make sure that the file “text.txt” exists in the working directory and has words in it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Lorem', 'ipsum', 'dolor', 'sit', 'amet,', 'consectetur', 'adipiscing', 'elit,', 'sed', 'do', 'eiusmod', 'tempor', 'incididunt', 'ut', 'labore', 'et', 'dolore', 'magna', 'aliqua.', 'Mollis', 'nunc', 'sed', 'id', 'semper', 'risus', 'in', 'hendrerit', 'gravida.', 'Tincidunt', 'augue', 'interdum', 'velit', 'euismod', 'in', 'pellentesque', 'massa.', 'Amet', 'dictum', 'sit', 'amet', 'justo', 'donec.', 'Eu', 'augue', 'ut', 'lectus', 'arcu', 'bibendum', 'at', 'varius.', 'Ut', 'sem', 'viverra', 'aliquet', 'eget', 'sit', 'amet', 'tellus.', 'Rhoncus', 'mattis', 'rhoncus', 'urna', 'neque', 'viverra.', 'Augue', 'lacus', 'viverra', 'vitae', 'congue', 'eu', 'consequat.', 'Imperdiet', 'proin', 'fermentum', 'leo', 'vel', 'orci', 'porta', 'non', 'pulvinar.', 'Cras', 'adipiscing', 'enim', 'eu', 'turpis', 'egestas', 'pretium', 'aenean.', 'Tristique', 'senectus', 'et', 'netus', 'et.', 'Ut', 'lectus', 'arcu', 'bibendum', 'at', 'varius', 'vel', 'pharetra', 'vel.', 'Arcu', 'felis', 'bibendum', 'ut', 'tristique.', 'At', 'tellus', 'at', 'urna', 'condimentum', 'mattis', 'pellentesque.', 'Tellus', 'in', 'metus', 'vulputate', 'eu.', 'Adipiscing', 'elit', 'pellentesque', 'habitant', 'morbi', 'tristique', 'senectus.']\n"
     ]
    }
   ],
   "source": [
    "def getWords():\n",
    "\t\n",
    "    f = open(\"text.txt\",\"r\")\n",
    "\t\n",
    "    words = f.readline().split()  \n",
    "\t#NOTE: readline() returns a string, while readlines() returns a list.\n",
    "\t#Also, split() works only on a string, NOT on a list, and returns a list.\n",
    "\t\n",
    "    return words\n",
    "\n",
    "# To call a function, you can do the following, for example:\n",
    "words = getWords()\n",
    "\n",
    "print(words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(14) Histograms:** Histograms (frequency plots) are very common plots that you will encounter in any statistics course. You can use numpy.histogram() or Python's inbuilt '.count()' method to generate frequency counts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 2 1] [ 97  98  99 100]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "letters = ['a','a','b','c','b']\n",
    "\n",
    "# numpy.histogram() won't run on a list of strings, so we convert them into ASCII numbers\n",
    "\n",
    "LettersInASCII = [ord(x) for x in letters]\n",
    "\n",
    "h = np.histogram(LettersInASCII, bins = list(range(ord('a'), ord('c') + 2)))\n",
    "\n",
    "# h[0] = counts for each number in LettersInASCII\n",
    "# h[1] = \"bins\" into which the numbers of LettersInASCII are put before counting\n",
    "# For more information on what \"bins\" mean, see \n",
    "# http://docs.scipy.org/doc/numpy/reference/generated/numpy.histogram.html\n",
    "\n",
    "print(h[0], h[1])  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A way to count frequencies directly on a list of strings without converting them into numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letters = ['a','a','b','c','b']\n",
    "\n",
    "letters.count('a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also make a dictionary of all the letters with their frequencies listed against each:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 2, 'b': 2, 'c': 1}"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict((x, letters.count(x)) for x in letters)  #akin to a list \"generator\" in iterm (5a) above"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(15) Plotting methods:** Use the package called 'matplotlib'. Typically, we use the subpackage 'matplotlib.pyplot' to do most of the plotting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot([1,2,4,7],[9,10,13,20])  #by default draws a blue line plot\n",
    "\n",
    "plt.xlabel('X axis')\n",
    "\n",
    "plt.ylabel('Y axis')\n",
    "\n",
    "plt.title('The simplest plot')\n",
    "\n",
    "plt.show()  #this is essential to display a plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make a bar plot, you can't use the usual 'plot()' method, instead you should call the 'bar()' function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAG2CAYAAACKxwc0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAe2klEQVR4nO3dfXBV9Z348c8laECBKFSeKo9FSwWRh7Bb0JZuVSxSFtutHQURy7ZTd6IFmXUBdVdhJaBtqbulC40rtB1LcTpKy46jFhBBussSECxqAZ+QrCOyVkgQt0GS+/vDn5mmIEIInHzN6zVzZrgnJ+d84hXv23PPyc3l8/l8AAAkqkXWAwAAnAgxAwAkTcwAAEkTMwBA0sQMAJA0MQMAJE3MAABJEzMAQNLEDACQNDEDACQt05g5dOhQ3HHHHdGrV69o3bp19O7dO2bNmhW1tbVZjgUAJKRllge/5557YuHChfHTn/40+vXrFxs3boxvfOMbUVRUFJMnT85yNAAgEZnGzH/913/F2LFjY/To0RER0bNnz/jFL34RGzduzHIsACAhmcbMJZdcEgsXLowdO3bE+eefH88++2ysW7cu7rvvviNuX11dHdXV1XWPa2tr4+23344OHTpELpc7RVMDACcin8/H/v37o2vXrtGiRSNc8ZLPUG1tbX769On5XC6Xb9myZT6Xy+VLS0s/dPs777wzHxEWi8VisVg+BktFRUWj9EQun8/nIyNLly6NW2+9Nb773e9Gv379YsuWLTFlypSYN29eTJw48bDt//zMTGVlZXTv3j0qKiqiXbt2p3J0AKCBqqqqolu3brFv374oKio64f1lGjPdunWL6dOnR0lJSd26u+++Ox588MHYtm3bR35/VVVVFBUVRWVlpZgBgEQ09ut3prdmv/vuu4e9V1ZQUODWbADgmGV6AfCYMWNi9uzZ0b179+jXr19s3rw55s2bF5MmTcpyLAAgIZm+zbR///74x3/8x1i2bFns2bMnunbtGtdee2380z/9U5x++ukf+f3eZgKA9DT263emMXOixAwApOdjdc0MAMCJEjMAQNLEDACQNDEDACRNzAAASRMzAEDSxAwAkDQxAwAkTcwAAEkTMwBA0sQMAJA0MQMAJE3MAABJEzMAQNLEDACQNDEDACRNzAAASRMzAEDSxAwAkDQxAwAkTcwAAEkTMwBA0sQMAJA0MQMAJE3MAABJEzMAQNLEDACQNDEDACRNzAAASRMzAEDSxAwAkDQxAwAkTcwAAEkTMwBA0sQMAJA0MQMAJE3MAABJEzMAQNLEDACQNDEDACRNzAAASRMzAEDSxAwAkDQxAwAkTcwAAEkTMwBA0sQMAJA0MQMAJE3MAABJEzMAQNLEDACQtExjpmfPnpHL5Q5bSkpKshwLAEhIyywPXl5eHjU1NXWPn3vuubj88svj6quvznAqACAlmcbMOeecU+/x3Llz41Of+lSMGDEio4kAgNRkGjN/6uDBg/Hggw/G1KlTI5fLHXGb6urqqK6urntcVVV1qsYDAJqoJhMzv/rVr2Lfvn1xww03fOg2c+bMiZkzZ566oQCgEfSc/mjWI3yonXNHZz3CCWsydzM98MADMWrUqOjateuHbjNjxoyorKysWyoqKk7hhABAU9Qkzsy89tprsXLlynjkkUeOul1hYWEUFhaeoqkAgBQ0iTMzixcvjo4dO8bo0emf6gIATq3MY6a2tjYWL14cEydOjJYtm8SJIgAgIZnHzMqVK2PXrl0xadKkrEcBABKU+amQkSNHRj6fz3oMACBRmZ+ZAQA4EWIGAEiamAEAkiZmAICkiRkAIGliBgBImpgBAJImZgCApIkZACBpYgYASJqYAQCSJmYAgKSJGQAgaWIGAEiamAEAkiZmAICkiRkAIGliBgBImpgBAJImZgCApIkZACBpYgYASJqYAQCSJmYAgKSJGQAgaWIGAEiamAEAkiZmAICkiRkAIGliBgBImpgBAJImZgCApIkZACBpYgYASJqYAQCSJmYAgKSJGQAgaWIGAEiamAEAkiZmAICkiRkAIGliBgBImpgBAJImZgCApIkZACBpYgYASJqYAQCSJmYAgKSJGQAgaWIGAEha5jHz+uuvx3XXXRcdOnSIM844IwYOHBibNm3KeiwAIBEtszz43r174+KLL46/+qu/isceeyw6duwYL7/8cpx11llZjgUAJCTTmLnnnnuiW7dusXjx4rp1PXv2zG4gACA5mb7NtHz58iguLo6rr746OnbsGIMGDYr777//Q7evrq6OqqqqegsA0LxlembmlVdeiQULFsTUqVPjtttuiw0bNsR3vvOdKCwsjOuvv/6w7efMmRMzZ87MYFLgWPSc/mjWIxzVzrmjsx4BOAkyPTNTW1sbgwcPjtLS0hg0aFB8+9vfjm9961uxYMGCI24/Y8aMqKysrFsqKipO8cQAQFOTacx06dIlLrjggnrrPvOZz8SuXbuOuH1hYWG0a9eu3gIANG+ZxszFF18c27dvr7dux44d0aNHj4wmAgBSk2nM3HLLLbF+/fooLS2Nl156KZYsWRJlZWVRUlKS5VgAQEIyjZmhQ4fGsmXL4he/+EX0798//vmf/znuu+++GD9+fJZjAQAJyfRupoiIL3/5y/HlL3856zEAgERl/nEGAAAnQswAAEkTMwBA0sQMAJA0MQMAJE3MAABJEzMAQNLEDACQNDEDACRNzAAASRMzAEDSxAwAkDQxAwAkTcwAAEkTMwBA0sQMAJA0MQMAJE3MAABJEzMAQNLEDACQNDEDACRNzAAASRMzAEDSxAwAkDQxAwAkTcwAAEkTMwBA0sQMAJA0MQMAJE3MAABJEzMAQNLEDACQNDEDACRNzAAASRMzAEDSxAwAkLQGxUzv3r3jD3/4w2Hr9+3bF7179z7hoQAAjlWDYmbnzp1RU1Nz2Prq6up4/fXXT3goAIBj1fJ4Nl6+fHndn5944okoKiqqe1xTUxOrVq2Knj17NtpwAAAf5bhi5qqrroqIiFwuFxMnTqz3tdNOOy169uwZ3//+9xttOACAj3JcMVNbWxsREb169Yry8vL4xCc+cVKGAgA4VscVMx949dVXG3sOAIAGaVDMRESsWrUqVq1aFXv27Kk7Y/OBRYsWnfBgAADHokExM3PmzJg1a1YUFxdHly5dIpfLNfZcAADHpEExs3DhwvjJT34SEyZMaOx5AACOS4N+z8zBgwdj+PDhjT0LAMBxa1DMfPOb34wlS5Y09iwAAMftmN9mmjp1at2fa2tro6ysLFauXBkDBgyI0047rd628+bNa7wJAQCO4phjZvPmzfUeDxw4MCIinnvuuXrrXQwMAJxKxxwzq1evPplzAAA0SIOumQEAaCoadGv2V77ylSO+nZTL5aJVq1bRp0+fGDduXHz6058+6n7uuuuumDlzZr11nTp1it27dzdkLACgGWrQmZmioqJ48skn45lnnqmLms2bN8eTTz4Zhw4dioceeiguuuii+O1vf/uR++rXr1+88cYbdcvWrVsbMhIA0Ew16MxM586dY9y4cTF//vxo0eL9HqqtrY3JkydH27ZtY+nSpXHjjTfGtGnTYt26dUcfoGXL6Ny5c0PGAABo2JmZBx54IKZMmVIXMhERLVq0iJtvvjnKysoil8vFTTfddNidTkfy4osvRteuXaNXr15xzTXXxCuvvPKh21ZXV0dVVVW9BQBo3hoUM4cOHYpt27Ydtn7btm1RU1MTERGtWrX6yNu0//Iv/zJ+9rOfxRNPPBH3339/7N69O4YPHx5/+MMfjrj9nDlzoqioqG7p1q1bQ8YHAD5GGvQ204QJE+Jv//Zv47bbbouhQ4dGLpeLDRs2RGlpaVx//fUREbFmzZro16/fUfczatSouj9feOGFMWzYsPjUpz4VP/3pT+v9kr4PzJgxo976qqoqQQMAzVyDYuYHP/hBdOrUKe6999548803I+L9u5BuueWWmDZtWkREjBw5Mr70pS8d137PPPPMuPDCC+PFF1884tcLCwujsLCwISMDAB9TDYqZgoKCuP322+P222+vu26lXbt29bbp3r37ce+3uro6fv/738fnPve5howFADRDJ/xL89q1a3dYyByrv//7v481a9bEq6++Gv/93/8dX/va16KqqiomTpx4omMBAM3EMZ+ZGTx4cKxatSrOPvvsGDRo0FEv7n3mmWeOaZ//8z//E9dee2289dZbcc4558RnP/vZWL9+ffTo0eNYxwIAmrljjpmxY8fWXa9y1VVXNcrBly5d2ij7AQCar2OOmTvvvPOIfwYAyFKDr5nZt29f/Pu//3vMmDEj3n777Yh4/+2l119/vdGGAwD4KA26m+l3v/tdXHbZZVFUVBQ7d+6Mb33rW9G+fftYtmxZvPbaa/Gzn/2ssecEADiiBp2ZmTp1atxwww3x4osvRqtWrerWjxo1KtauXdtowwEAfJQGxUx5eXl8+9vfPmz9Jz/5ydi9e/cJDwUAcKwaFDOtWrU64oc8bt++Pc4555wTHgoA4Fg1KGbGjh0bs2bNivfeey8iInK5XOzatSumT58ef/M3f9OoAwIAHE2DYuZ73/te/O///m907Ngx/u///i9GjBgRffr0iTZt2sTs2bMbe0YAgA/VoLuZ2rVrF+vWrYvVq1fHpk2bora2NgYPHhyXXXZZY88HAHBUDYqZiIhVq1bFqlWrYs+ePVFbWxvbtm2LJUuWRETEokWLGm1AAICjaVDMzJw5M2bNmhXFxcXRpUuXo35OEwDAydSgmFm4cGH85Cc/iQkTJjT2PAAAx6VBFwAfPHgwhg8f3tizAAActwbFzDe/+c2662MAALJ0zG8zTZ06te7PtbW1UVZWFitXrowBAwbEaaedVm/befPmNd6EAABHccwxs3nz5nqPBw4cGBERzz33XL31LgYGAE6lY46Z1atXn8w5AAAapEHXzAAANBViBgBImpgBAJImZgCApIkZACBpYgYASJqYAQCSJmYAgKSJGQAgaWIGAEiamAEAkiZmAICkiRkAIGliBgBImpgBAJImZgCApIkZACBpYgYASJqYAQCSJmYAgKSJGQAgaWIGAEiamAEAkiZmAICkiRkAIGliBgBImpgBAJImZgCApIkZACBpYgYASJqYAQCSJmYAgKSJGQAgaU0mZubMmRO5XC6mTJmS9SgAQEKaRMyUl5dHWVlZDBgwIOtRAIDEZB4z77zzTowfPz7uv//+OPvss7MeBwBITOYxU1JSEqNHj47LLrss61EAgAS1zPLgS5cujWeeeSbKy8uPafvq6uqorq6ue1xVVXWyRgMAEpHZmZmKioqYPHlyPPjgg9GqVatj+p45c+ZEUVFR3dKtW7eTPCUA0NRlFjObNm2KPXv2xJAhQ6Jly5bRsmXLWLNmTfzrv/5rtGzZMmpqag77nhkzZkRlZWXdUlFRkcHkAEBTktnbTJdeemls3bq13rpvfOMb0bdv35g2bVoUFBQc9j2FhYVRWFh4qkYEABKQWcy0bds2+vfvX2/dmWeeGR06dDhsPQDAh8n8biYAgBOR6d1Mf+6pp57KegQAIDHOzAAASRMzAEDSxAwAkDQxAwAkTcwAAEkTMwBA0sQMAJA0MQMAJE3MAABJEzMAQNLEDACQNDEDACRNzAAASRMzAEDSxAwAkDQxAwAkTcwAAEkTMwBA0sQMAJA0MQMAJE3MAABJEzMAQNLEDACQNDEDACRNzAAASRMzAEDSxAwAkDQxAwAkTcwAAEkTMwBA0sQMAJA0MQMAJE3MAABJEzMAQNLEDACQNDEDACRNzAAASRMzAEDSxAwAkDQxAwAkTcwAAEkTMwBA0sQMAJA0MQMAJE3MAABJEzMAQNLEDACQNDEDACRNzAAASRMzAEDSxAwAkLRMY2bBggUxYMCAaNeuXbRr1y6GDRsWjz32WJYjAQCJyTRmzj333Jg7d25s3LgxNm7cGF/84hdj7Nix8fzzz2c5FgCQkJZZHnzMmDH1Hs+ePTsWLFgQ69evj379+mU0FQCQkkxj5k/V1NTEL3/5yzhw4EAMGzbsiNtUV1dHdXV13eOqqqpTNR4A0ERlHjNbt26NYcOGxR//+Mdo06ZNLFu2LC644IIjbjtnzpyYOXPmKZ7wyHpOfzTrEY5q59zRWY8AAKdE5nczffrTn44tW7bE+vXr4+/+7u9i4sSJ8cILLxxx2xkzZkRlZWXdUlFRcYqnBQCamszPzJx++unRp0+fiIgoLi6O8vLy+Jd/+Zf48Y9/fNi2hYWFUVhYeKpHBACasMzPzPy5fD5f77oYAICjyfTMzG233RajRo2Kbt26xf79+2Pp0qXx1FNPxeOPP57lWABAQjKNmTfffDMmTJgQb7zxRhQVFcWAAQPi8ccfj8svvzzLsQCAhGQaMw888ECWhwcAPgaa3DUzAADHQ8wAAEkTMwBA0sQMAJA0MQMAJE3MAABJEzMAQNLEDACQNDEDACRNzAAASRMzAEDSxAwAkDQxAwAkTcwAAEkTMwBA0sQMAJA0MQMAJE3MAABJEzMAQNLEDACQNDEDACRNzAAASRMzAEDSxAwAkDQxAwAkTcwAAEkTMwBA0sQMAJA0MQMAJE3MAABJEzMAQNLEDACQNDEDACRNzAAASRMzAEDSxAwAkDQxAwAkTcwAAEkTMwBA0sQMAJA0MQMAJE3MAABJEzMAQNLEDACQNDEDACRNzAAASRMzAEDSxAwAkDQxAwAkTcwAAEkTMwBA0jKNmTlz5sTQoUOjbdu20bFjx7jqqqti+/btWY4EACQm05hZs2ZNlJSUxPr162PFihVx6NChGDlyZBw4cCDLsQCAhLTM8uCPP/54vceLFy+Ojh07xqZNm+Lzn/98RlMBACnJNGb+XGVlZUREtG/f/ohfr66ujurq6sO2r6qqOvnD/Zna6ndP+TGPRxb/TMDfCziypvx3I4u/Fx8cM5/PN8r+cvnG2tMJyufzMXbs2Ni7d288/fTTR9zmrrvuipkzZ57iyQCAk+Hll1+O3r17n/B+mkzMlJSUxKOPPhrr1q2Lc88994jb/PmZmX379kWPHj1i165dUVRUdKpG5QiqqqqiW7duUVFREe3atct6nGbP89F0eC6aDs9F01FZWRndu3ePvXv3xllnnXXC+2sSbzPdfPPNsXz58li7du2HhkxERGFhYRQWFh62vqioyL+YTUS7du08F02I56Pp8Fw0HZ6LpqNFi8a5DynTmMnn83HzzTfHsmXL4qmnnopevXplOQ4AkKBMY6akpCSWLFkSv/71r6Nt27axe/fuiHj/TEvr1q2zHA0ASESmv2dmwYIFUVlZGV/4wheiS5cudctDDz10TN9fWFgYd9555xHfeuLU8lw0LZ6PpsNz0XR4LpqOxn4umswFwAAADeGzmQCApIkZACBpYgYASJqYAQCSlnTM/Nu//Vv06tUrWrVqFUOGDPnQj0Hg5JkzZ04MHTo02rZtGx07doyrrroqtm/fnvVYxPvPTS6XiylTpmQ9SrP0+uuvx3XXXRcdOnSIM844IwYOHBibNm3Keqxm6dChQ3HHHXdEr169onXr1tG7d++YNWtW1NbWZj3ax97atWtjzJgx0bVr18jlcvGrX/2q3tfz+Xzcdddd0bVr12jdunV84QtfiOeff/64j5NszDz00EMxZcqUuP3222Pz5s3xuc99LkaNGhW7du3KerRmZc2aNVFSUhLr16+PFStWxKFDh2LkyJFx4MCBrEdr1srLy6OsrCwGDBiQ9SjN0t69e+Piiy+O0047LR577LF44YUX4vvf/36j/Np2jt8999wTCxcujPnz58fvf//7uPfee+O73/1u/PCHP8x6tI+9AwcOxEUXXRTz588/4tfvvffemDdvXsyfPz/Ky8ujc+fOcfnll8f+/fuP70D5RP3FX/xF/sYbb6y3rm/fvvnp06dnNBH5fD6/Z8+efETk16xZk/Uozdb+/fvz5513Xn7FihX5ESNG5CdPnpz1SM3OtGnT8pdccknWY/D/jR49Oj9p0qR667761a/mr7vuuowmap4iIr9s2bK6x7W1tfnOnTvn586dW7fuj3/8Y76oqCi/cOHC49p3kmdmDh48GJs2bYqRI0fWWz9y5Mj4z//8z4ymIuL9Dw+LiGjfvn3GkzRfJSUlMXr06LjsssuyHqXZWr58eRQXF8fVV18dHTt2jEGDBsX999+f9VjN1iWXXBKrVq2KHTt2RETEs88+G+vWrYsrr7wy48mat1dffTV2795d77W8sLAwRowYcdyv5U3igyaP11tvvRU1NTXRqVOneus7depU95EInHr5fD6mTp0al1xySfTv3z/rcZqlpUuXxjPPPBPl5eVZj9KsvfLKK7FgwYKYOnVq3HbbbbFhw4b4zne+E4WFhXH99ddnPV6zM23atKisrIy+fftGQUFB1NTUxOzZs+Paa6/NerRm7YPX6yO9lr/22mvHta8kY+YDuVyu3uN8Pn/YOk6dm266KX73u9/FunXrsh6lWaqoqIjJkyfHb37zm2jVqlXW4zRrtbW1UVxcHKWlpRERMWjQoHj++edjwYIFYiYDDz30UDz44IOxZMmS6NevX2zZsiWmTJkSXbt2jYkTJ2Y9XrPXGK/lScbMJz7xiSgoKDjsLMyePXsOKzxOjZtvvjmWL18ea9eujXPPPTfrcZqlTZs2xZ49e2LIkCF162pqamLt2rUxf/78qK6ujoKCggwnbD66dOkSF1xwQb11n/nMZ+Lhhx/OaKLm7dZbb43p06fHNddcExERF154Ybz22msxZ84cMZOhzp07R8T7Z2i6dOlSt74hr+VJXjNz+umnx5AhQ2LFihX11q9YsSKGDx+e0VTNUz6fj5tuuikeeeSRePLJJ6NXr15Zj9RsXXrppbF169bYsmVL3VJcXBzjx4+PLVu2CJlT6OKLLz7sVxTs2LEjevTokdFEzdu7774bLVrUf7krKChwa3bGevXqFZ07d673Wn7w4MFYs2bNcb+WJ3lmJiJi6tSpMWHChCguLo5hw4ZFWVlZ7Nq1K2688casR2tWSkpKYsmSJfHrX/862rZtW3e2rKioKFq3bp3xdM1L27ZtD7tW6cwzz4wOHTq4hukUu+WWW2L48OFRWloaX//612PDhg1RVlYWZWVlWY/WLI0ZMyZmz54d3bt3j379+sXmzZtj3rx5MWnSpKxH+9h755134qWXXqp7/Oqrr8aWLVuiffv20b1795gyZUqUlpbGeeedF+edd16UlpbGGWecEePGjTu+AzXG7VZZ+dGPfpTv0aNH/vTTT88PHjzY7cAZiIgjLosXL856NPJ5t2Zn6D/+4z/y/fv3zxcWFub79u2bLysry3qkZquqqio/efLkfPfu3fOtWrXK9+7dO3/77bfnq6ursx7tY2/16tVHfI2YOHFiPp9///bsO++8M9+5c+d8YWFh/vOf/3x+69atx32cXD6fzzdGfQEAZCHJa2YAAD4gZgCApIkZACBpYgYASJqYAQCSJmYAgKSJGQAgaWIGaJJ69uwZ9913X9ZjAAkQMwBA0sQMAJA0MQM0uh//+MfxyU9+8rBPJf7rv/7rmDhxYrz88ssxduzY6NSpU7Rp0yaGDh0aK1eu/ND97dy5M3K5XGzZsqVu3b59+yKXy8VTTz1Vt+6FF16IK6+8Mtq0aROdOnWKCRMmxFtvvdXYPx7QxIgZoNFdffXV8dZbb8Xq1avr1u3duzeeeOKJGD9+fLzzzjtx5ZVXxsqVK2Pz5s1xxRVXxJgxY2LXrl0NPuYbb7wRI0aMiIEDB8bGjRvj8ccfjzfffDO+/vWvN8aPBDRhLbMeAPj4ad++fXzpS1+KJUuWxKWXXhoREb/85S+jffv2cemll0ZBQUFcdNFFddvffffdsWzZsli+fHncdNNNDTrmggULYvDgwVFaWlq3btGiRdGtW7fYsWNHnH/++Sf2QwFNljMzwEkxfvz4ePjhh6O6ujoiIn7+85/HNddcEwUFBXHgwIH4h3/4h7jgggvirLPOijZt2sS2bdtO6MzMpk2bYvXq1dGmTZu6pW/fvhER8fLLLzfKzwQ0Tc7MACfFmDFjora2Nh599NEYOnRoPP300zFv3ryIiLj11lvjiSeeiO9973vRp0+faN26dXzta1+LgwcPHnFfLVq8//9d+Xy+bt17771Xb5va2toYM2ZM3HPPPYd9f5cuXRrrxwKaIDEDnBStW7eOr371q/Hzn/88XnrppTj//PNjyJAhERHx9NNPxw033BBf+cpXIiLinXfeiZ07d37ovs4555yIeP+6mEGDBkVE1LsYOCJi8ODB8fDDD0fPnj2jZUv/aYPmxNtMwEkzfvz4ePTRR2PRokVx3XXX1a3v06dPPPLII7Fly5Z49tlnY9y4cYfd+fSnWrduHZ/97Gdj7ty58cILL8TatWvjjjvuqLdNSUlJvP3223HttdfGhg0b4pVXXonf/OY3MWnSpKipqTlpPyOQPTEDnDRf/OIXo3379rF9+/YYN25c3fof/OAHcfbZZ8fw4cNjzJgxccUVV8TgwYOPuq9FixbFe++9F8XFxTF58uS4++676329a9eu8dvf/jZqamriiiuuiP79+8fkyZOjqKio7m0q4OMpl//TN6EBABLjf1cAgKSJGQAgaWIGAEiamAEAkiZmAICkiRkAIGliBgBImpgBAJImZgCApIkZACBpYgYASJqYAQCS9v8ALdkLUm73SWMAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "values = [1,5,9]\n",
    "barheights = [3,6,7]\n",
    "\n",
    "plt.bar(values, barheights)\n",
    "\n",
    "plt.xlabel('value')\n",
    "plt.ylabel('height')\n",
    "plt.axis([0,10,2,8])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use 'hist()' to make a histogram by passing to it a list of raw data. Use the 'normed' parameter to specify if you want raw frequency counts or normalized probability values. The example below also shows how to annotate a plot -- use 'annotate(text, x-y tuple of the plot to be annotated, x-y tuple specifying where in the plot area the text is to be placed, **other parameters like arrow properties)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = [1,2,3,2,2,1,1,3,4,4,4,4,4,5,5,6,2,3,1,4]\n",
    "\n",
    "plt.hist(data, bins=6, facecolor='brown', alpha=0.5)  #compute raw frequencies\n",
    "\n",
    "plt.axis([0,7,0,7])  #specify the range of values accepted on each axis\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sample exercises\n",
    "This is NOT the answer to the exercises listed in Lab1. This is a sample question and answer given to give an idea of how to approach the exercises listed in Lab1.\n",
    "\n",
    "1.  Read in the text file\n",
    "2.  Count the frequencies of characters in the text, plot a histogram.\n",
    "3.  Calculate the Shannon entropy of the text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First let's open the .txt file and then we can read the text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "text = open(\"text.txt\", \"r\")\n",
    "my_text = text.read()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution 2.\n",
    "Now let's get the frequencies of the characters in the text.\n",
    "First we can set an empty dictionary where we'll save the frequencies.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "frequencies = {}\n",
    " \n",
    "for character in my_text:          \n",
    "    if character in frequencies:    \n",
    "        frequencies[character] += 1 \n",
    "    else:                           \n",
    "        frequencies[character] = 1  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For every character in my text we open a \"class\" in our dictionary associated to that character and if the character appears in the text, we add '1' to the class in other case we can just set '1' to take the character into account."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted_freqs = dict(sorted(frequencies.items())) #We are sorting the items in the dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's plot a histogram.\n",
    "To construct the histogram we are basically taking the keys in the x-axis and the respective values of those keys in the y-axis. \n",
    "NOTE: Since we have not cleaned the text, this dictionary will contain values such as '\\n','\\ufeff' which won't show in the histogram. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 43 artists>"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.xlabel('Characters') \n",
    "plt.ylabel('Frequency') \n",
    "plt.title('Frequencies of characters in the text') \n",
    "plt.bar(sorted_freqs.keys(), sorted_freqs.values()) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.197647087087611"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "prob={} #making a dictionary with probability values instead of frequencies\n",
    "for key,value in sorted_freqs.items():  # this for loop runs through every item of the sorted_freq dictionary\n",
    "    prob[key]=value/sum(sorted_freqs.values())\n",
    "\n",
    "H=0 #seting H to zero\n",
    "for key,value in prob.items():\n",
    "    H+= -value* np.log2(value)\n",
    "\n",
    "H"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.197647087087612\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# An alternative way using lists to count characters in a text and their corresponding probabilities.\n",
    "prob = [(c, my_text.count(c)/len(my_text)) for c in set(my_text)]\n",
    "\n",
    "#calculating shannon entropy for the text\n",
    "H = sum(-p*np.log2(p) for (c, p) in prob)\n",
    "print(H)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}