January 15 - Loops Functions Modules .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# January 15 - Loops, Functions, Modules\n",
    "\n",
    "### Prerequisites\n",
    "* Sections 6 and 7 of the Udemy Complete Python Programming course\n",
    "* Section 6 and 7 of the Packt Beginning Python Video course\n",
    "* Review sections 1-5 of the Packt Beginning Python Video course - most of this will be a review of material from the Udemy course\n",
    "\n",
    "### Assignment\n",
    "Today we're going to use your knowledge of loops functions and modules to write a text analytics program with the following capability\n",
    "* Build a word count function that takes a string and returns a dictionary with the word and it's count.  You already wrote this code last week.  We'll just put it in a function in a stand-alone module\n",
    "* Build a function to find the union of words in two strings.  That is all the words that both strings have in common.\n",
    "* Build a function to find all the words that are in one string that aren't in another string.\n",
    "\n",
    "Next we'll introduce the idea of tests - you'll develop tests for all you code.   And we'll talk about Test Driven Development\n",
    "\n",
    "Lastly you'll build a stand alone program that uses the functions you created to perform text analytics on two blocks of text a user provides."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Text Analytics Module\n",
    "* First create a file called textanalytics.py file in a subdirectory called src.\n",
    "* copy all your wordcount code from last week into this file.\n",
    "* make your wordcount code into a function that takes a string and returns a dictionary with the frequency distribution of words in it.\n",
    "* test it with the code in the following cells"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from src import textanalytics as ta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "d1=ta.wordcount(\"now is the time for all good men to come to the aid of their party\")\n",
    "d2=ta.wordcount(\"the quick brown fox jumped over the sleeping dog\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#One Word Tests\n",
    "d1=ta.wordcount(\"one\")\n",
    "assert len(d1)==1   # test there is only 1 word in the result\n",
    "assert d1[\"one\"]==1 # test count of the word \"one\" is 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Three Word Tests\n",
    "d2=ta.wordcount(\"one two three\")\n",
    "assert len(d2)==3  # test there are 3 words in the result\n",
    "assert d2[\"one\"]==1 # test each word has a count of 1\n",
    "assert d2[\"two\"]==1\n",
    "assert d2[\"three\"]==1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test Driven Development\n",
    "\n",
    "Listen to the video on [Test Driven Development](https://youtu.be/uGaNkTahrIw)\n",
    "\n",
    "Before writing your code for the next funciton - discuss ways that you can test it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Union Function\n",
    "Create a function called a_union_b() in your text analytics module.  Write code to return a list of all the words that are in two dictionaries created from wordcount that get passed to the function.  The cells below contain some tests you can run to make sure your code does what it's supposed to do."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['the']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l=ta.a_union_b(d1,d2)\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#test that a_union_b(['one','two','three'],['one']) returns 'one'\n",
    "u=ta.a_union_b(d1,d2)\n",
    "assert(u==['one'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Words in A but not in B\n",
    "Create a funciton called in_a_not_in_b() in your text analytics module.   Write the code that takes two dictionaries from your wordcount function and return the words that are in the fist string but are not in the second string.  Again before you write this code think about ways to test it will do what you want it to do.   The cells below include a few tests you can use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['now',\n",
       " 'is',\n",
       " 'time',\n",
       " 'for',\n",
       " 'all',\n",
       " 'good',\n",
       " 'men',\n",
       " 'to',\n",
       " 'come',\n",
       " 'aid',\n",
       " 'of',\n",
       " 'their',\n",
       " 'party']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l=ta.in_a_not_in_b(d1,d2)\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['quick', 'brown', 'fox', 'jumped', 'over', 'sleeping', 'dog']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l=ta.in_a_not_in_b(d2,d1)\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l=ta.in_a_not_in_b(d1,d1)\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#test that in_a_not_in_b of \"one\", \"one\" return an empty set\n",
    "assert ta.in_a_not_in_b(d1,d1)==[]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['two', 'three']\n"
     ]
    }
   ],
   "source": [
    "#test that in_a_not_in_b of ['one','two','three'],['one'] returns a set with both 'two' and 'three' in it\n",
    "l=ta.in_a_not_in_b(d2,d1)\n",
    "assert(\"two\" in l)\n",
    "assert(\"three\" in l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stand Alone program to drive your text analytics functions\n",
    "The last step is to write a stand alone program called compare_two_paragraphs.py that asks the user for two strings, and exercises your text analytics functions.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:3.6]",
   "language": "python",
   "name": "conda-env-3.6-py"
  },
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}