S05-App-1-Build-an-Interactive-Dictionary.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Python Mega Course: Build 10 Real World Applications\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook contains the source code for the video lectures of Section 5 of [The Python Mega Course: Build 10 Real World Applciations](https://www.udemy.com/the-python-mega-course/?couponCode=GITHEADSECTION)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Section 5: Application 1: Build an Interactive Dictionary\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Lecture:** [Demonstration of the Interactive Dictionary](https://www.udemy.com/the-python-mega-course/learn/v4/t/lecture/7627770?start=0)\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This project consists of building an English dictionary where users can submit a word and the program returns the definition of the word. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Download [here](http://pythonhow.com/data/python-mega-course-data/app1/) the data needed for this application"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Lecture:** [The Data Source](https://www.udemy.com/the-python-mega-course/learn/v4/t/lecture/7627808?start=0)\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The data used for this project is a json dataset that contains an English dictionary. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Lecture:** [Loading the JSON Data into a Python Dictionary](https://www.udemy.com/the-python-mega-course/learn/v4/t/lecture/7627840?start=0)\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import json\n",
    "data = json.load(open(\"data.json\"))\n",
    "type(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Lecture:** [Returning the Definition of a Word](https://www.udemy.com/the-python-mega-course/learn/v4/t/lecture/7627840?start=0)\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter word: rain\n",
      "['Precipitation in the form of liquid water drops with diameters greater than 0.5 millimetres.', 'To fall from the clouds in drops of water.']\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "data = json.load(open(\"data.json\"))\n",
    "def translate(w):\n",
    "    return data[w]\n",
    "word = input(\"Enter word: \")\n",
    "print(translate(word))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Lecture:** [Counting for Non-existing Words](https://www.udemy.com/the-python-mega-course/learn/v4/t/lecture/7627870?start=0)\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter word: rainn\n",
      "The word doesn't exist. Please double check it.\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "data = json.load(open(\"data.json\"))\n",
    "def translate(w):\n",
    "    if w in data:\n",
    "        return data[w]\n",
    "    else:\n",
    "        return \"The word doesn't exist. Please double check it.\"\n",
    "word = input(\"Enter word: \")\n",
    "print(translate(word))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Lecture:** [Making the Program Letter Case Insensitive]()\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter word: RAIn\n",
      "['Precipitation in the form of liquid water drops with diameters greater than 0.5 millimetres.', 'To fall from the clouds in drops of water.']\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "data = json.load(open(\"data.json\"))\n",
    "def translate(w):\n",
    "    w = w.lower()\n",
    "    if w in data:\n",
    "        return data[w]\n",
    "    else:\n",
    "        return \"The word doesn't exist. Please double check it.\"\n",
    "word = input(\"Enter word: \")\n",
    "print(translate(word))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Lecture:** [Calculating Similarity Ratio Between Two Words](https://www.udemy.com/the-python-mega-course/learn/v4/t/lecture/7627914?start=0)\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8888888888888888"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#this is just testing. It's not part of the application code\n",
    "#returns the similarity ratio two words\n",
    "from difflib import SequenceMatcher\n",
    "SequenceMatcher(None, \"rain\", \"rainn\").ratio()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can interpret the above number as rain with rainn are 88% similar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Lecture:** [Finding the Best Match of a Word out of a List of Words](https://www.udemy.com/the-python-mega-course/learn/v4/t/lecture/7627930?start=0)\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['rain']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#this is just testing. It's not part of the application code\n",
    "#given a word, returns its closest match from a list of words\n",
    "from difflib import get_close_matches\n",
    "get_close_matches(\"rainn\", [\"help\", \"pyramid\", \"rain\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above result means that \"rain\" is the item of the list that is closer to the word \"rainn\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['rain', 'train', 'rainy']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#getting the closest matchesb\n",
    "out of all the dictionary keys\n",
    "get_close_matches(\"rainn\", data.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default you get the top three closest words of the given sequence. You can change that as following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['rain', 'train', 'rainy', 'grain', 'drain']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#getting the top five closest matches\n",
    "get_close_matches(\"rainn\", data.keys(), n = 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'rain'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#the first item of the result list is the closest one\n",
    "#you can extract that item using [0]\n",
    "get_close_matches(\"rainn\", data.keys(), n = 5)[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Lecture:** [Making the Program Suggest a Similar Word](https://www.udemy.com/the-python-mega-course/learn/v4/t/lecture/7627942?start=0)\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter word: rainn\n",
      "Did you mean rain instead?\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "from difflib import get_close_matches\n",
    "\n",
    "data = json.load(open(\"data.json\"))\n",
    "def translate(w):\n",
    "    w = w.lower()\n",
    "    if w in data:\n",
    "        return data[w]\n",
    "    elif len(get_close_matches(w, data.keys())) > 0:\n",
    "        return \"Did you mean %s instead?\" % get_close_matches(w, data.keys())[0]\n",
    "    else:\n",
    "        return \"The word doesn't exist. Please double check it.\"\n",
    "word = input(\"Enter word: \")\n",
    "print(translate(word))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Lecture:** [Prompting the User to Confirm Similarity Check](https://www.udemy.com/the-python-mega-course/learn/v4/t/lecture/7627950?start=0)\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter word: rainn\n",
      "Did you mean rain instead? Enter Y if yes, or N if no: Y\n",
      "['Precipitation in the form of liquid water drops with diameters greater than 0.5 millimetres.', 'To fall from the clouds in drops of water.']\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "from difflib import get_close_matches\n",
    "\n",
    "data = json.load(open(\"data.json\"))\n",
    "def translate(w):\n",
    "    w = w.lower()\n",
    "    if w in data:\n",
    "        return data[w]\n",
    "    elif len(get_close_matches(w, data.keys())) > 0:\n",
    "        yn = input(\"Did you mean %s instead? Enter Y if yes, or N if no: \" % get_close_matches(w, data.keys())[0])\n",
    "        if yn == \"Y\":\n",
    "            return data[get_close_matches(w, data.keys())[0]]\n",
    "        elif yn == \"N\":\n",
    "            return \"The word doesn't exist. Please double check it.\"\n",
    "        else:\n",
    "            return \"We didn't understand your entry.\"\n",
    "    else:\n",
    "        return \"The word doesn't exist. Please double check it.\"\n",
    "\n",
    "word = input(\"Enter word: \")\n",
    "print(translate(word))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Lecture:** [Optimizing the Final Output](https://www.udemy.com/the-python-mega-course/learn/v4/t/lecture/7627982?start=0)\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter word: rainn\n",
      "Did you mean rain instead? Enter Y if yes, or N if no: Y\n",
      "Precipitation in the form of liquid water drops with diameters greater than 0.5 millimetres.\n",
      "To fall from the clouds in drops of water.\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "from difflib import get_close_matches\n",
    "\n",
    "data = json.load(open(\"data.json\"))\n",
    "\n",
    "def translate(w):\n",
    "    w = w.lower()\n",
    "    if w in data:\n",
    "        return data[w]\n",
    "    elif len(get_close_matches(w, data.keys())) > 0:\n",
    "        yn = input(\"Did you mean %s instead? Enter Y if yes, or N if no: \" % get_close_matches(w, data.keys())[0])\n",
    "        if yn == \"Y\":\n",
    "            return data[get_close_matches(w, data.keys())[0]]\n",
    "        elif yn == \"N\":\n",
    "            return \"The word doesn't exist. Please double check it.\"\n",
    "        else:\n",
    "            return \"We didn't understand your entry.\"\n",
    "    else:\n",
    "        return \"The word doesn't exist. Please double check it.\"\n",
    "\n",
    "word = input(\"Enter word: \")\n",
    "\n",
    "output = translate(word)\n",
    "\n",
    "if type(output) == list:\n",
    "    for item in output:\n",
    "        print(item)\n",
    "else:\n",
    "    print(output)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Lecture:** [Exercise](https://www.udemy.com/the-python-mega-course/learn/v4/t/lecture/8235648?start=0)\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's currently a bug in the program. When the user inputs a proper noun (e.g. Delhi, Paris, etc.) the program will convert it to lowercase and then tries to find the lowercase version (e.g. delhi) in the dataset and it cannot find it since the dataset has Delhi, but not delhi. \n",
    "\n",
    "Please add another conditional block to the program so that the program returns the definition of names that start with a capital letter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Lecture:** [Solution](https://www.udemy.com/the-python-mega-course/learn/v4/t/lecture/8235752?start=0)\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make sure the program returns the definition of words that start with a capital letter (e.g. Delhi, Texas) line 8 and 9 were added:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter word: Delhi\n",
      "The largest metropolis by area and the second-largest metropolis by population in India.\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "from difflib import get_close_matches\n",
    "data = json.load(open(\"data.json\"))\n",
    "def translate(w):\n",
    "    w = w.lower()\n",
    "    if w in data:\n",
    "        return data[w]\n",
    "    elif w.title() in data: #if user entered \"texas\" this will check for \"Texas\" as well.\n",
    "        return data[w.title()]\n",
    "    elif len(get_close_matches(w, data.keys())) > 0:\n",
    "        yn = input(\"Did you mean %s instead? Enter Y if yes, or N if no: \" % get_close_matches(w, data.keys())[0])\n",
    "        if yn == \"Y\":\n",
    "            return data[get_close_matches(w, data.keys())[0]]\n",
    "        elif yn == \"N\":\n",
    "            return \"The word doesn't exist. Please double check it.\"\n",
    "        else:\n",
    "            return \"We didn't understand your entry.\"\n",
    "    else:\n",
    "        return \"The word doesn't exist. Please double check it.\"\n",
    " \n",
    "word = input(\"Enter word: \")\n",
    "output = translate(word)\n",
    "if type(output) == list:\n",
    "    for item in output:\n",
    "        print(item)\n",
    "else:\n",
    "    print(output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see from the comments I included in the code, I have added another conditional in line 8 and 9. The w.title()  will convert the first letter to uppercase and the rest to lowercase. So, if the program didn't find anything for \"texas\" in the first conditional in lines 6-7 then this conditional will try to search for \"Texas\". Even if the user entered \"TEXAS\", this conditional will convert it to \"Texas\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Lecture:** [Exercise](https://www.udemy.com/the-python-mega-course/learn/v4/t/lecture/8677004?start=0)\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A student discovered another issue with the program. The program cannot return the definition of acronyms such as USA or NATO. Therefore, please try to add another conditional that makes the program return the definition of such words. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Lecture:** [Solution](https://www.udemy.com/the-python-mega-course/learn/v4/t/lecture/8677006?start=0)\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make sure the program returns the definition of acronyms (e.g. USA, NATO) line 10 and 11 were added: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter word: NATO\n",
      "An international organization created in 1949 by the North Atlantic Treaty for purposes of collective security.\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "from difflib import get_close_matches\n",
    "data = json.load(open(\"data.json\"))\n",
    "def translate(w):\n",
    "    w = w.lower()\n",
    "    if w in data:\n",
    "        return data[w]\n",
    "    elif w.title() in data:\n",
    "        return data[w.title()]\n",
    "    elif w.upper() in data: #in case user enters words like USA or NATO\n",
    "        return data[w.upper()]\n",
    "    elif len(get_close_matches(w, data.keys())) > 0:\n",
    "        yn = input(\"Did you mean %s instead? Enter Y if yes, or N if no: \" % get_close_matches(w, data.keys())[0])\n",
    "        if yn == \"Y\":\n",
    "            return data[get_close_matches(w, data.keys())[0]]\n",
    "        elif yn == \"N\":\n",
    "            return \"The word doesn't exist. Please double check it.\"\n",
    "        else:\n",
    "            return \"We didn't understand your entry.\"\n",
    "    else:\n",
    "        return \"The word doesn't exist. Please double check it.\"\n",
    "word = input(\"Enter word: \")\n",
    "output = translate(word)\n",
    "if type(output) == list:\n",
    "    for item in output:\n",
    "        print(item)\n",
    "else:\n",
    "    print(output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Lecture:** [Final Code of Application 1]()\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import json\n",
    "from difflib import get_close_matches\n",
    "data = json.load(open(\"data.json\"))\n",
    "def translate(w):\n",
    "    w = w.lower()\n",
    "    if w in data:\n",
    "        return data[w]\n",
    "    elif w.title() in data:\n",
    "        return data[w.title()]\n",
    "    elif w.upper() in data: #in case user enters words like USA or NATO\n",
    "        return data[w.upper()]\n",
    "    elif len(get_close_matches(w, data.keys())) > 0:\n",
    "        yn = input(\"Did you mean %s instead? Enter Y if yes, or N if no: \" % get_close_matches(w, data.keys())[0])\n",
    "        if yn == \"Y\":\n",
    "            return data[get_close_matches(w, data.keys())[0]]\n",
    "        elif yn == \"N\":\n",
    "            return \"The word doesn't exist. Please double check it.\"\n",
    "        else:\n",
    "            return \"We didn't understand your entry.\"\n",
    "    else:\n",
    "        return \"The word doesn't exist. Please double check it.\"\n",
    "word = input(\"Enter word: \")\n",
    "output = translate(word)\n",
    "if type(output) == list:\n",
    "    for item in output:\n",
    "        print(item)\n",
    "else:\n",
    "    print(output)"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}