Coding the Matrix Chapter 0.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Coding the Matrix\n",
    "# Chapter 0 - The Functions\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Set__ :- A set is a collection of mathematical objects in which each object is considered to occur atmost once. The objects belonging to a set are called its elements.\n",
    "\n",
    "* One set $S_{1}$ is contained in another set $S_{2}$ if every element of $S_{1}$ belongs to $S_{2}$. \n",
    "\n",
    "* Two sets are equal if they contain exactly the same elements.\n",
    "\n",
    "__Cardinality of a set__ :- No. of elements a set contains, represented as |A|.\n",
    "\n",
    "__Cartesian Product__ :- Cartesian product of two sets A and B is the set of all the pairs (a,b) where $a\\  \\epsilon \\  A\\  and\\  b\\  \\epsilon \\  B$\n",
    "\n",
    "* For finite sets A and B |A X B| = |A|.|B|."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Function__ :- A function is a rule that, for each element in a set D of possible inputs, assign an output.\n",
    "* The output is called the _image_ of the input under the function and the input is called _pre image_ of the output under the function.\n",
    "* The set of all the possible inputs is called _domain_ of the function.\n",
    "* _Co-domain_ is the set from which the function's output values are choosen. Not all the elements in the co domain set has to be an image of the inputs. So, _image_ is the set of elements of _co-domain_ that actually occur as output.\n",
    "\n",
    "Formally, function is a set of pairs (a,b), no two of which shares the same first entry.\n",
    "\n",
    "For a function named *f*, the image of *q* under *f* is denoted by _f(q)_. If _r = f(q)_, then we say, _q maps to r under f_.\n",
    "\n",
    "Notation :- $$f : D\\  -> F\\ or\\ F^D$$ \n",
    "\n",
    "* For any finite sets D and F, $|F^D|\\ = \\ |F|^{|D|}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function versus Procedures, versus computational problem\n",
    "\n",
    "__Procedures__ are the precise desription of the computation, that takes an input and provides output.\n",
    "\n",
    "__Computational Problem__ is and input-output specification that a procedures might be required to satisfy. This does not tell us how to calculated the output from input.\n",
    "\n",
    "__For e.g.__ :- \n",
    "Computational problem :- input a pair of integers (p,q). Output is the product of these 2 numbers pq.  \n",
    "Procedure will be the description of the algorithm for calculating the product. Eg. Long multiplication, Furer algo. etc.\n",
    "\n",
    "* Unlike a function, computational problem need not to have single output for an input.\n",
    "\n",
    "* Same procedure can be used for different functions. We can use same function of multiplication to calculate the multiplication of integers, non integers.\n",
    "\n",
    "For each function f, there is a corresponding computational problem. We can call it forward problem.\n",
    "\n",
    "__Forward problem__ :- Given an element a of _f's_ domain, calculate image of a under f.\n",
    "\n",
    "__Backward Problem__ :- Given a element r of the co-domain of the function, calculate its pre-image under f(if exists)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Some definitions related to functions\n",
    "\n",
    "__Identity Function__ :- For any domain, there is a function $i_D$ : D -> D and is called identity function of D such that $$i_D(d)\\  =\\  d$$ where d$\\epsilon$D.\n",
    "\n",
    "__Composition of functions__ :- Combine 2 functions to get a new function. E.g. For 2 functions, *f*: A -> B and *g*: B -> C, the composition of f and g has domain as A and co domain as C and is defined as $$(g\\ \\ \\ f)(x)\\ =\\ g(f(x))$$ for every x$\\epsilon$A.\n",
    "\n",
    "__Functional Inverse__ :- A function say g that reverse the effect of a function say f, is called the functional inverse of f. Not every function has an inverse and if it exist then the function is said to be _invertible_.\n",
    "\n",
    "Functions f and g are functional inverse of each other if \n",
    "* (f  g) is defined and is the identity function over the domain of g, and \n",
    "* (g  f) is defined and is the identity function over the domain of f.\n",
    "\n",
    "__One-to-One function__ :- A function _f: D -> F_ is said to be one-to-one function if for every x,y $\\epsilon$ D, _f(x) = f(y)_ implies x = y. This means no 2 elements in the domain can have the same image under the function f.\n",
    "\n",
    "__Onto Function__ :- A function _f: D -> F_ is said to be onto function if for every _z_ $\\epsilon$ F, there exists x $\\epsilon$ D, such that _f(x) = z_. This means that all the elements in the co-domain of the function has a pre image under the function f.\n",
    "\n",
    "* A invertible function is also one-to-one and onto.\n",
    "* A function is invertible if and only if it is one-to-one and onto.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Invertibility of composition of invertible functions\n",
    "\n",
    "If f and g are two invertible functions and (f. g) exists, then (f. g) is also invertible and \n",
    "$$(f. g)^{-1} = g^{-1}\\ f^{-1}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Probability Theory\n",
    "In probablity theory, we study about the uncertain events. It is about what could happen, and how likely it is to happen.\n",
    "\n",
    "#### Probability Distribution\n",
    "A function Pr(.) from a finite domain # to the set of non negative real numbers $R^+$ is a (discrete)probability distribution if $\\sum Pr(.) = 1$.\n",
    "\n",
    "The elements of the domain are called _outcomes_. The image of the outcomes under Pr(.) are called the _probability_ of the outcome. The probabilities are supposed to be proportional to the _relative likelihood_ of the outcomes.\n",
    "\n",
    "__Uniform Distribution__:- If all the outcomes are equally likely , so they are all assigned the same probability. Then, we say that the probability distribution is _uniform_. For e.g. tossing of a coin has equal probability of getting a head and tail. We write the distribution as\n",
    "$$Pr = \\{heads:1/2,\\ tails:1/2\\}$$\n",
    "\n",
    "__Non Uniform Distribution__ :- If all the outcomes has different probabilities, then the distribution is non-uniform.\n",
    "For e.g. In a bag of 10 white balls and 5 red balls, likelihood of drawing a white ball is twice the likelihood of drawing a red ball. We need to assign probability proportional to these likelihood. We must have some number c such that probability of drawing that ball should be c times the no. of balls of that color.\n",
    "$$Pr[drawing\\ a\\ red\\ ball] = c. (No.\\ of\\ red\\ balls)$$\n",
    "Since the total no. of balls are 15, we define c = 1/15. The probability of drawing a red ball is 5/15 i.e. 0.33.\n",
    "\n",
    "#### Events and adding probabilities\n",
    "An set of outcomes is called an _event_. For eg. An event of selecting a vowel from 26 alphabets is an event {A,E,I,O,U}.\n",
    "\n",
    "__Fundamental principal of probability theory__ :- The probability of an event is the sum of the probabilities of the outcomes making up that event.\n",
    "\n",
    "* If we apply a function to a random input, then the output of the function should also be random. If we know the distribution of input and the function, then we can use probability to derive the probability distribution of the output.\n",
    "\n",
    "__Example__ :- Consider the tossing of 2 coins. The outcome is a pair (x,y) where each x and y can be 'H' or 'T'. Let's define a fucntion f such that $$f((x,y))\\ =\\ no\\ of\\ H's\\ represented$$\n",
    "Now we know the distribution of the input. Each 'H' and 'T' has equal chances 1/2. Using this information we can drive the distribution of the output.\n",
    "\n",
    "$${0:1/4,\\ 1:1/2,\\ 2:1/4}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Lab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Solution of all the tasks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "604800"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.1\n",
    "# Using Python as a calculator\n",
    "# No. of minutes in a week\n",
    "7*24*60*60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.2\n",
    "# To find the remainder\n",
    "2304811%47"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Boolean Operators used for comparisons and returns TRUE or FALSE__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.3\n",
    "# Examples :-\n",
    "(673+909)%3 == 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Conditional Expressions__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.4\n",
    "x = -9\n",
    "y = 1/2\n",
    "2**(y+1/2) if x+10<0 else 2**(y-1/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Collections in Python (data structure to store multiple items)\n",
    "#### 1. Sets\n",
    "__Sets can be defined using the {} brackets in python.__\n",
    "1. Sets are mutable.\n",
    "2. We cannot store duplicates in sets.\n",
    "3. A set cannot be a part of a set.\n",
    "\n",
    "An empty set can be represented as set()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 'a'}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Defining a set \n",
    "{1+2, 3, 'a'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The above result gave only 2 element as sets cannot store duplicates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Cardinality of a set.\n",
    "len({'a','b','c','a','a'})\n",
    "# Python first remove the duplicates from the set and then calculate the length of the set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Summing the elements of a set\n",
    "sum({1,2,3})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# if we want to start the sum not at zero but at a different value, then pass it as second argument\n",
    "sum({1,2,3},10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# testing the membership of an element in a set.\n",
    "1 in {1,2,3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 not in {1,2,3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Union of 2 sets is a set that contains all the elements that is a member of either 1st set or the other.\n",
    "# Union of sets is done by using '|' operator\n",
    "{1,2,3,4} | {3,4,5,6}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 4}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Intersection of 2 sets is a set that common elements from both the sets.\n",
    "# Intersection of sets is done by using '&' operator\n",
    "{1,2,3,4} & {3,4,5,6}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Mutating a set\n",
    "# adding an element in the set\n",
    "S = {1,2,3}\n",
    "S.add(4)\n",
    "S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 4}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# removing an element from the set\n",
    "S.remove(2)\n",
    "S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 4, 5, 6}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# more than one element can be added to the set using \"update\"\n",
    "S.update({4,5,6})\n",
    "S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 5, 6}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# intersection_update will take the intersection of the set and the argument provided and update the existing set.\n",
    "S.intersection_update({4,5,6})\n",
    "S"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Note that all the function above change the original form of the set.__\n",
    "__We can also create copy of the set and then make changes in the set using \"copy\".__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "T = S.copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set Comprehensions\n",
    "__Most Important feature of Python is comprehension. Comprehension helps us in shrinking the length of the code.__\n",
    "\n",
    "__Few examples of comprehensions.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 4, 6}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set Comprehensions example 1 :- return twice of each no. in a set\n",
    "{2*x for x in {1,2,3}}\n",
    "# This is called a set comprehension because its value is a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 4, 9, 16, 25}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.5\n",
    "# Set Comprehensions example 2 :- return square of each no. in a set\n",
    "{x**2 for x in {1,2,3,4,5}}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 4, 8, 16}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.6\n",
    "# Set Comprehensions example 3 :- return exponential of each no. in a set\n",
    "{2**x for x in {0,1,2,3,4}}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 4, 9, 16, 25, 49}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set comprehension with union and intersection\n",
    "S = {1,2,3,4}\n",
    "{x*x for x in S | {5,7}}\n",
    "# This will combine the S with set {5,7} and then apply the comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{9, 16, 25, 49}"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can also filter values from the results using if condition in the end. \n",
    "{x*x for x in S | {5,7} if x > 2}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 5, 6, 8, 10, 12, 15, 18}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.7\n",
    "# Double Comprehension can be written like this.\n",
    "{x*y for x in {1,2,3} for y in {4,5,6}}\n",
    "# we are multiplying every element of x with every element of y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3, 4, 6, 8, 12}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.8\n",
    "#Double Comprehension with a filter\n",
    "{x*y for x in {1,2,3} for y in {2,3,4} if x!=y}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 4}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.9\n",
    "# finding common items in 2 sets\n",
    "S = {1,2,3,4}\n",
    "T = {3,4,5,6}\n",
    "{x for x in S for y in T if x==y}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Lists\n",
    "__List can be defined using [ ] brackets.__\n",
    "\n",
    "1.Lists are mutable.\n",
    "\n",
    "2.List allow duplicate items.\n",
    "\n",
    "An empty list can be written as []."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 2, 3, 2]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Saving some elements in a list\n",
    "[1,1+1,2,3,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], {3, 4, 5}, 'yo']"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A list can contain a set or list.\n",
    "[[1,1+1,3],{2*2,3,5},\"yo\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# length of a list or a set can calculated using \"len\" function\n",
    "len([[1,1+1,3],{2*2,3,5},\"yo\",\"yo\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sum of a list or a set can be calculated using \"sum\" function\n",
    "sum([1,1,0,1,0,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30.0"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.10\n",
    "# Average of elements in a list\n",
    "S = [20,10,15,75]\n",
    "sum(S)/len(S)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 'my', 'word']"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List Concatenation. Combining 2 lists to make a new list.\n",
    "[1,2,3] + [\"my\",\"word\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 'my', 'word']"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sum function can be used for concatenation of lists by providing [] as second argument.\n",
    "sum([[1,2,3] , [\"my\",\"word\"]],[])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List Comprehension\n",
    "\n",
    "__Notice that the bracket outside the comprehension is [ ] which mean it will return a list. if brackets are {} the it will retrun a set__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List Comprehensions\n",
    "[2*x for x in {2,1,3,4}]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 2, 6, 8]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Please note that list do not sort you elements but set does.\n",
    "# In above command as the operation is done on a set, the result that came out was sorted in ascending order.\n",
    "# Below command will not produce a sorted result as the operation is done on a list.\n",
    "[2*x for x in [2,1,3,4]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 20, 40, 60, 30, 60, 90]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Double Comprehension in lists\n",
    "[x*y for x in [1,2,3] for y in [10,20,30]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['A', 1],\n",
       " ['A', 2],\n",
       " ['A', 3],\n",
       " ['B', 1],\n",
       " ['B', 2],\n",
       " ['B', 3],\n",
       " ['C', 1],\n",
       " ['C', 2],\n",
       " ['C', 3]]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.11\n",
    "# double list comprehension on 2 lists\n",
    "[[x,y] for x in ['A','B','C'] for y in [1,2,3]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16.1"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.12\n",
    "# Caluculating sum of all elemnts in a list\n",
    "LofL = [[.25,.75,.1],[-1,0],[4,4,4,4]]\n",
    "sum([sum(LofL[0]),sum(LofL[1]),sum(LofL[2])])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 10, 20, 30, 40]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Indexing and slicing of a list can be done using [ ]\n",
    "# Eg. \n",
    "L = [0,10,20,30,40,50,60,70,80,90]\n",
    "# First 5 elements of L \n",
    "L[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[50, 60, 70, 80, 90]"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 5th onwards elements of a list\n",
    "L[5:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 20, 40, 60, 80]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#slicing that skips\n",
    "# Slice the cth element\n",
    "L[::2] # Index with even numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 30, 50, 70, 90]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[1::2] # Index with odd numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Obtaining elements of a list by unpacking.\n",
    "# assingning a list of variables\n",
    "[x,y,z] = [4*1, 4*2, 4*3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "not enough values to unpack (expected 4, got 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-55-b8e6a10ec69c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Task 0.5.13\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# length should match on both sides while unpacking a list.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;34m[\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m12\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m45\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: not enough values to unpack (expected 4, got 3)"
     ]
    }
   ],
   "source": [
    "# Task 0.5.13\n",
    "# length should match on both sides while unpacking a list.\n",
    "[a,b,c,d] = [12,45,6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 1, 30]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can mutate a list, replacing its ith element using indexing.\n",
    "mlist = [10,20,30]\n",
    "mlist[1] =1\n",
    "mlist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. Tuples\n",
    "__Tuples can be defined using () brackets__\n",
    "\n",
    "1. Tuples are immutable.\n",
    "2. Tuples allow duplicates.\n",
    "3. Tuples can be used as element of a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3)"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A tuple\n",
    "(1,1+1,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(1, 2), (3, 4, 5), 0}"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Tuples(immutable) can be a part of the set\n",
    "{0,(1,2)} | {(3,4,5)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.14"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A set can be a element of Tuples\n",
    "(1,{\"A\",\"B\"},3.14)[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Unpacking with tuples\n",
    "(a,b) = (1,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Some comprehensions using tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 0, 0),\n",
       " (0, 2, -2),\n",
       " (0, -2, 2),\n",
       " (1, 1, -2),\n",
       " (1, -2, 1),\n",
       " (2, 0, -2),\n",
       " (2, 2, -4),\n",
       " (2, -4, 2),\n",
       " (2, -2, 0),\n",
       " (-4, 2, 2),\n",
       " (-2, 0, 2),\n",
       " (-2, 1, 1),\n",
       " (-2, 2, 0)]"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.14\n",
    "# Creating all possible three element tuple from a set whose sum is zero.\n",
    "S = {-4,-2,1,2,5,0}\n",
    "[(x,y,z) for x in S for y in S for z in S if x+y+z == 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 2, -2),\n",
       " (0, -2, 2),\n",
       " (1, 1, -2),\n",
       " (1, -2, 1),\n",
       " (2, 0, -2),\n",
       " (2, 2, -4),\n",
       " (2, -4, 2),\n",
       " (2, -2, 0),\n",
       " (-4, 2, 2),\n",
       " (-2, 0, 2),\n",
       " (-2, 1, 1),\n",
       " (-2, 2, 0)]"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.15\n",
    "# Creating all possible three element tuple from a set whose sum is zero bu do not include (0,0,0).\n",
    "[(x,y,z) for x in S for y in S for z in S if x+y+z == 0 and (x,y,z) != (0,0,0)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 2, -2)"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Task 0.5.16\n",
    "[(x,y,z) for x in S for y in S for z in S if x+y+z == 0 and (x,y,z) != (0,0,0)][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2, 3, 4}"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''Python can compute a set from another collection (e.g. a list) using the constructor set(·). \n",
    "Similarly, the constructor list(·) computes a list, and the constructor tuple(·) computes a tuple '''\n",
    "# list to set\n",
    "set([0,1,2,3,4,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2, 3, 4}"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# tuples to set\n",
    "set((0,1,2,3,4,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# set to list\n",
    "list({0,1,2,3,4,4})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 4]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# tuple to list\n",
    "list((0,1,2,3,4,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1, 2, 3, 4, 4)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# list to tuples \n",
    "tuple([0,1,2,3,4,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1, 2, 3, 4)"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# set to tuples\n",
    "tuple({0,1,2,3,4,4})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object <genexpr> at 0x107dfbfc0>"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "''' If we try to create a tuple using comrehensions then the result will be a generator not a tuple.\n",
    "We can iterate over generator as well. The good thing about generator is that it does not saved in the memory.'''\n",
    "(x for x in (1,2,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ranges \n",
    "__A range plays the role of a list consisting of the elements of an arithmetic progression.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 10)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(10) # this represents a list from 0 to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 4, 9, 16, 25, 36, 49, 64, 81}"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can iterate over a range as well.\n",
    "{x*x for x in range(10)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a range is not a list, we need to convert it using list() function\n",
    "list(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(10, 20)"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(10,20) # a sequence between 10 to 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(10, 20, 2)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(10,20,2) # a sequence between 10 to 20 with a jump of 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 12, 14, 16, 18]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(10,20,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Zip\n",
    "__A zip is constructed from other collections all of the same length.__\n",
    "\n",
    "__Each element of the zip is a tuple consisting of one element from each of the input collections.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 3), (2, 4), (3, 5)]"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip([1,2,3],[3,4,5]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Neo is played by keanu',\n",
       " 'Morepheus is played by Launrence',\n",
       " 'Trinity is played by Carrie-Anne']"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# An example of zip\n",
    "characters = ['Neo','Morepheus','Trinity']\n",
    "actors = ['keanu','Launrence','Carrie-Anne']\n",
    "set(zip(characters,actors))\n",
    "\n",
    "[characters+' is played by '+actors for (characters,actors) in zip(characters,actors)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'A'), (1, 'B'), (2, 'C'), (3, 'D'), (4, 'E')]"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.19\n",
    "L = ['A','B','C','D','E']\n",
    "list(zip(range(5),L))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11, 40, 60]"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.20\n",
    "# sum of consecutive elements using zip\n",
    "[x+y for (x,y) in zip([10,25,40],[1,15,20])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 2, 1]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reversed changes the order of the list\n",
    "[x for x in  reversed([1,2,3])]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionaries\n",
    "__A dictionary is a set of key-value pairs. Defined as 'key:value'__\n",
    "\n",
    "__Functions with finite domain can be defined usind dictionaries in Python.__\n",
    "\n",
    "__keys of the dictonaries can not be duplicate__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2: 'two', 3: 'three', 5: 'five'}"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{2:'two',3:'three',5:'five'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys([2, 3, 5])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# to get the keys from the dictionary\n",
    "{2:'two',3:'three',5:'five'}.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['two', 'three', 'five'])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# to get the values from the dictionary\n",
    "{2:'two',3:'three',5:'five'}.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'two'"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# indexing into python dictionaries\n",
    "{2:'two',3:'three',5:'five'}[2]\n",
    "# Please note that '2' in the square bracket do not mean 2nd element but key = 2. Hence the result would be 'two'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'keanu'"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Another example\n",
    "mydict = {'Neo': 'keanu','Morepheus':'Laurence','Trninity':'Carrie-Anne'}\n",
    "mydict['Neo']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# testing the membership is done by key not by value\n",
    "'Neo' in mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sean', 'Roger', 'Pierce']"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.21\n",
    "# Returning the values of a key from a list of dictionaries\n",
    "dlist = [{'James':'Sean','director':'Terence'},{'James':'Roger','director':'Lewis'},{'James':'Pierce','director':'Roger'}]\n",
    "[x['James'] for x in dlist]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Elijah', 'NotPresent']"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.22\n",
    "# Returning the values of a key from a list of dictionaries and \"not present\" if the key is missing.\n",
    "dlist = [{'Bilbo':'Ian','Frodo':'Elijah'},{'Bilbo':'Martin','Thorin':'Richard'}]\n",
    "[x['Bilbo'] if 'Bilbo' in x else 'NotPresent' for x in dlist]\n",
    "[x['Frodo'] if 'Frodo' in x else 'NotPresent' for x in dlist]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Neo': 'keanu',\n",
       " 'Morepheus': 'Laurence',\n",
       " 'Trninity': 'Carrie-Anne',\n",
       " 'Agent Smith': 'Hugo'}"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Mutating a dictionary.\n",
    "# We can change the value for a key using indexing. We can use the same for adding a key:value pair.\n",
    "mydict['Agent Smith'] = 'Hugo'\n",
    "mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3: 2, 4: 0, 100: 1}"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A dictionary can be created using a comprehension.\n",
    "{k:v for (k,v) in [(3,2),(4,0),(100,1)]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0,\n",
       " 1: 1,\n",
       " 2: 4,\n",
       " 3: 9,\n",
       " 4: 16,\n",
       " 5: 25,\n",
       " 6: 36,\n",
       " 7: 49,\n",
       " 8: 64,\n",
       " 9: 81,\n",
       " 10: 100,\n",
       " 11: 121,\n",
       " 12: 144,\n",
       " 13: 169,\n",
       " 14: 196,\n",
       " 15: 225,\n",
       " 16: 256,\n",
       " 17: 289,\n",
       " 18: 324,\n",
       " 19: 361,\n",
       " 20: 400,\n",
       " 21: 441,\n",
       " 22: 484,\n",
       " 23: 529,\n",
       " 24: 576,\n",
       " 25: 625,\n",
       " 26: 676,\n",
       " 27: 729,\n",
       " 28: 784,\n",
       " 29: 841,\n",
       " 30: 900,\n",
       " 31: 961,\n",
       " 32: 1024,\n",
       " 33: 1089,\n",
       " 34: 1156,\n",
       " 35: 1225,\n",
       " 36: 1296,\n",
       " 37: 1369,\n",
       " 38: 1444,\n",
       " 39: 1521,\n",
       " 40: 1600,\n",
       " 41: 1681,\n",
       " 42: 1764,\n",
       " 43: 1849,\n",
       " 44: 1936,\n",
       " 45: 2025,\n",
       " 46: 2116,\n",
       " 47: 2209,\n",
       " 48: 2304,\n",
       " 49: 2401,\n",
       " 50: 2500,\n",
       " 51: 2601,\n",
       " 52: 2704,\n",
       " 53: 2809,\n",
       " 54: 2916,\n",
       " 55: 3025,\n",
       " 56: 3136,\n",
       " 57: 3249,\n",
       " 58: 3364,\n",
       " 59: 3481,\n",
       " 60: 3600,\n",
       " 61: 3721,\n",
       " 62: 3844,\n",
       " 63: 3969,\n",
       " 64: 4096,\n",
       " 65: 4225,\n",
       " 66: 4356,\n",
       " 67: 4489,\n",
       " 68: 4624,\n",
       " 69: 4761,\n",
       " 70: 4900,\n",
       " 71: 5041,\n",
       " 72: 5184,\n",
       " 73: 5329,\n",
       " 74: 5476,\n",
       " 75: 5625,\n",
       " 76: 5776,\n",
       " 77: 5929,\n",
       " 78: 6084,\n",
       " 79: 6241,\n",
       " 80: 6400,\n",
       " 81: 6561,\n",
       " 82: 6724,\n",
       " 83: 6889,\n",
       " 84: 7056,\n",
       " 85: 7225,\n",
       " 86: 7396,\n",
       " 87: 7569,\n",
       " 88: 7744,\n",
       " 89: 7921,\n",
       " 90: 8100,\n",
       " 91: 8281,\n",
       " 92: 8464,\n",
       " 93: 8649,\n",
       " 94: 8836,\n",
       " 95: 9025,\n",
       " 96: 9216,\n",
       " 97: 9409,\n",
       " 98: 9604,\n",
       " 99: 9801}"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.23\n",
    "# Creating a disctionary using range and comprehension.\n",
    "{x:x**2 for x in range(100)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'red': 'red', 'blue': 'blue', 'white': 'white'}"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.24\n",
    "# Identity function over D\n",
    "D = {'red','white','blue'}\n",
    "{x:x for x in D}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: [0, 0, 0],\n",
       " 1: [0, 0, 1],\n",
       " 2: [0, 0, 2],\n",
       " 3: [0, 0, 3],\n",
       " 4: [0, 0, 4],\n",
       " 5: [0, 0, 5],\n",
       " 6: [0, 0, 6],\n",
       " 7: [0, 0, 7],\n",
       " 8: [0, 0, 8],\n",
       " 9: [0, 0, 9],\n",
       " 10: [0, 1, 0],\n",
       " 11: [0, 1, 1],\n",
       " 12: [0, 1, 2],\n",
       " 13: [0, 1, 3],\n",
       " 14: [0, 1, 4],\n",
       " 15: [0, 1, 5],\n",
       " 16: [0, 1, 6],\n",
       " 17: [0, 1, 7],\n",
       " 18: [0, 1, 8],\n",
       " 19: [0, 1, 9]}"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.25\n",
    "# Mapping integers to their representation in base 10.\n",
    "base = 10\n",
    "digits = set(range(base))\n",
    "{x:[a,b,c] for x in range(20) for a in digits for b in digits for c in digits if (base**2)*a+(base**1)*b+(base**0)*c == x}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 6]"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Comprehensions to iterate over dictionaries\n",
    "[2*x for x in {4:'a',3:'b'}.keys()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['aa', 'bb']"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[2*x for x in {4:'a',3:'b'}.values() ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['c', 'a', 'b']"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can write comprehension that run over the union of keys of many dictionaries.\n",
    "[k for k in {'a':1, 'b':2}.keys() | {'b':3, 'c':4}.keys()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Neo', 'keanu'),\n",
       " ('Morepheus', 'Laurence'),\n",
       " ('Trninity', 'Carrie-Anne'),\n",
       " ('Agent Smith', 'Hugo')]"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can get the key:value pair in form of a list as well. Each apir would be a tuple.\n",
    "[myitem for myitem in mydict.items()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Larry': 1000.0, 'Moe': 900, 'Curly': 1200.5}"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.26\n",
    "id2salary = {0:1000.0, 3:900,1:1200.50}\n",
    "names = ['Larry','Curly','','Moe']\n",
    "{names[x]:id2salary[x] for x in id2salary.keys()}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### One-line procedures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 1, 2, 3]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# keyword def defines the procedure. \n",
    "# They are like functions but can only be defined if the result can be computed using one expression.\n",
    "def twice(z): return z*2\n",
    "# Task 0.5.27\n",
    "# twice('sad')\n",
    "twice([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 6, 8]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.28\n",
    "def nextInts(L) : return [x+1 for x in L]\n",
    "nextInts([1,5,7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 8, 27]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.29\n",
    "def cubes(L) : return [z**3 for z in L]\n",
    "cubes([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['B', 'C', 'A']"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.30\n",
    "def dict2list(dct,keylist) : return [dct[x] for x in keylist]\n",
    "dict2list({'a':'A', 'b':'B', 'c':'C'},['b','c','a'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'A', 'b': 'B', 'c': 'C'}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.31\n",
    "def list2dict(L, keylist) : return {keylist[x]:L[x] for x in range(len(keylist))}\n",
    "list2dict(['A','B','C'],['a','b','c'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.5.32\n",
    "def all_3_digits_number(base,digits): return [x for x in range(100) for a in digits for b in digits for c in digits if (base**2)*a+(base**1)*b+(base**0)*c == x]\n",
    "all_3_digits_number(2,{0,1})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0,\n",
       " 1,\n",
       " 2,\n",
       " 3,\n",
       " 4,\n",
       " 5,\n",
       " 6,\n",
       " 7,\n",
       " 8,\n",
       " 9,\n",
       " 10,\n",
       " 11,\n",
       " 12,\n",
       " 13,\n",
       " 14,\n",
       " 15,\n",
       " 16,\n",
       " 17,\n",
       " 18,\n",
       " 19,\n",
       " 20,\n",
       " 21,\n",
       " 22,\n",
       " 23,\n",
       " 24,\n",
       " 25,\n",
       " 26]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_3_digits_number(3,{0,1,2})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Python Lab - modules and control structures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modules can be imported using the import command in python. \n",
    "# help(module) can be used to get help on the module.\n",
    "# Task 0.6.1\n",
    "import math\n",
    "#help(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A gem!'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.6.2\n",
    "# Using random module\n",
    "from random import randint\n",
    "review = ['See it!','A gem!','Ideological claptrap']\n",
    "def movie_review(name) : return(review[randint(0,len(review)-1)])\n",
    "movie_review('Ground Hog Day')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['',\n",
       " '/Users/atyagi/anaconda3/lib/python36.zip',\n",
       " '/Users/atyagi/anaconda3/lib/python3.6',\n",
       " '/Users/atyagi/anaconda3/lib/python3.6/lib-dynload',\n",
       " '/Users/atyagi/anaconda3/lib/python3.6/site-packages',\n",
       " '/Users/atyagi/anaconda3/lib/python3.6/site-packages/aeosa',\n",
       " '/Users/atyagi/anaconda3/lib/python3.6/site-packages/IPython/extensions',\n",
       " '/Users/atyagi/.ipython']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can look at the path where python search for modules\n",
    "import sys\n",
    "sys.path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Task 0.6.3\n",
    "# We can add the path where python search for modules\n",
    "# Look at the dictutil.py file in module folder in the reporsitory for the solution.\n",
    "sys.path.append(\"/Users/atyagi/Desktop/Coding the Matrix - Python/Coding-the-matrix-Code/Modules\")\n",
    "import dictutil # importing our module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['B', 'C', 'A']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dictutil.dict2list({'a':'A', 'b':'B', 'c':'C'},['b','c','a'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'dictutil' from '/Users/atyagi/Desktop/Coding the Matrix - Python/Coding-the-matrix-Code/Modules/dictutil.py'>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can relaod a module using reload \n",
    "from imp import reload\n",
    "reload(dictutil)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 'A', 1: 'B', 2: 'C'}"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.6.4\n",
    "# Look at the dictutil.py file in module folder in the reporsitory for the solution.\n",
    "dictutil.listrange2dict(['A','B','C'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are some traditional for and while loops that can be used for iterating over lists, tuples etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# We need to take care of the indentation while writing loops, functions and conditional expressions\n",
    "for i in range(4):\n",
    "    y = i*i\n",
    "    print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Breaking out of the loop can be done using break statement.\n",
    "s = \"There is no spoon\"\n",
    "for i in range(len(s)):\n",
    "    if s[i] == 'n':\n",
    "        break\n",
    "        \n",
    "i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reading from a file\n",
    "# file is a python object that is used to refer to and access a file.\n",
    "f = open(\"/Users/atyagi/Desktop/Coding the Matrix - Python/Coding-the-matrix-Code/text_files/stories_small.txt\")\n",
    "# This open command returns a file object that can be used to access that particular file.\n",
    "#Now we can read the file line by line using a for loop\n",
    "#for line in f:\n",
    "#    print(line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can also use list to obtain a list of lines.\n",
    "stories = list(f)\n",
    "len(stories)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Mini Search Engine\n",
    "From a file of documents, we will build a data structure(called inverse index) that identifies documents contain any given word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ask', 'not', 'what', 'you', 'can', 'do', 'for', 'your', 'country']"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can split a string with spaces into substrings using split()\n",
    "mystr = 'Ask not what you can do for your country'\n",
    "mystr.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'A'), (1, 'B'), (2, 'C')]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can iterate through elements and also keep track of the indices using enumerate()\n",
    "list(enumerate(['A','B','C']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Task 0.6.6\n",
    "def makeInverseIndex(strlist):\n",
    "    word_appear = {}\n",
    "    for (i,doc) in enumerate(strlist):\n",
    "        for word in doc.split():\n",
    "            if word in word_appear:\n",
    "                word_appear[word].add(i)\n",
    "            else:\n",
    "                word_appear[word] = set([i])\n",
    "                              \n",
    "    return(word_appear)\n",
    "stories_word_list = makeInverseIndex(stories)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8681"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(stories_word_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1099"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stories_big = []\n",
    "f_big = open(\"/Users/atyagi/Desktop/Coding the Matrix - Python/Coding-the-matrix-Code/text_files/stories_big.txt\")\n",
    "for line in f_big:\n",
    "    stories_big.append(line)\n",
    "len(stories_big)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "44564"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stories_big_word_list = makeInverseIndex(stories_big)\n",
    "len(stories_big_word_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{7, 8, 11, 15, 18, 21, 22, 24, 29, 35, 43, 44, 47, 48, 49}"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.6.7\n",
    "def orSearch(inverseIndex, query):\n",
    "    ordoc = set()\n",
    "    for word in query:\n",
    "        if word in inverseIndex:\n",
    "            ordoc.update(inverseIndex[word])\n",
    "    \n",
    "    return(ordoc)\n",
    "orSearch(stories_word_list,['story','love'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "162"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(orSearch(stories_big_word_list,['story','love']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{18, 21, 22}"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 0.6.8\n",
    "def andSearch(inverseIndex, query):\n",
    "    anddoc = set()\n",
    "    for word in query:\n",
    "        if word in inverseIndex:\n",
    "            if len(anddoc) == 0:\n",
    "                anddoc.update(inverseIndex[word])\n",
    "            else:\n",
    "                anddoc = anddoc & inverseIndex[word]\n",
    "    return anddoc\n",
    "andSearch(stories_word_list,['story','love'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{18,\n",
       " 21,\n",
       " 22,\n",
       " 127,\n",
       " 134,\n",
       " 153,\n",
       " 164,\n",
       " 169,\n",
       " 266,\n",
       " 459,\n",
       " 513,\n",
       " 593,\n",
       " 597,\n",
       " 704,\n",
       " 807,\n",
       " 823,\n",
       " 833,\n",
       " 853,\n",
       " 855,\n",
       " 883,\n",
       " 918,\n",
       " 928,\n",
       " 1095}"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "andSearch(stories_big_word_list,['story','love'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Problems "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Python Comprehension problems"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 6, 8]"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Problem 0.8.1\n",
    "def increments(L) : return [x+1 for x in L]\n",
    "increments([1,5,7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 8, 27]"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Problem 0.8.2\n",
    "def cubes(L) : return [z**3 for z in L]\n",
    "cubes([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(4, 6), (40, 60)]"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Problem 0.8.3\n",
    "def tuple_sum(A,B) : return [(a+x,b+y) for ((a,b),(x,y)) in list(zip(A,B))]\n",
    "tuple_sum([(1, 2), (10, 20)],[(3, 4), (30, 40)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'merci': 'thank you', 'au revoir': 'goodbye'}"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Problem 0.8.4\n",
    "def inv_dict(d) : return {v:k for (k,v) in d.items()}\n",
    "inv_dict({'thank you': 'merci', 'goodbye': 'au revoir'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 11, 12, 13]"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Problem 0.8.5\n",
    "def row(p,n) : return [p+i for i in range(n)]\n",
    "row(10,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "#[row(i,20) for i in range(2,17)]\n",
    "#[[x+i for i in range(20)]  for x in range(2,17)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Theory problems__\n",
    "\n",
    "_Problem 0.8.6_\n",
    "\n",
    "The function is one-to-one. All elments have a unique image in the co-domain.\n",
    "\n",
    "The function is onto. All elements in co-domain have a pre-image under the function.\n",
    "\n",
    "Hence this function is invertible"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Problem 0.8.7_\n",
    "\n",
    "The function is one-to-one. All elments have a unique image in the co-domain.\n",
    "\n",
    "The function is not onto. Last elements in co-domain do not have a pre-image under the function.\n",
    "\n",
    "Hence this function is not invertible.\n",
    "To make it invertible remove the last element of co-domain."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Problem 0.8.8_\n",
    "\n",
    "All the elements of co-domain of the function f should be a part of the domain of the function f."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Problem 0.8.9_\n",
    "\n",
    "Yes, the f o g exists. The reason mentioned above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Problem 0.8.10_\n",
    "\n",
    "To calculate the prob. of an event, we sum the prob. of all the outcome that make up that event.\n",
    "\n",
    "Pr(even no.) = Pr(1) + Pr(3) + Pr(5) = 0.5 + 0.1 + 0.1 = 0.7.\n",
    "\n",
    "Pr(odd no.) = Pr(2) + Pr(6) = 0.2 + 0.1 = 0.3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Problem 0.8.11_\n",
    "\n",
    "Prob(1) = Pr(1) + Pr(4) + Pr(7) = 0.2 + 0.1 + 0.1 = 0.4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}